From b165a254fda970c1adee3eb23d772c8f240537eb Mon Sep 17 00:00:00 2001
From: blankll <zilisheng1996@gmail.com>
Date: Sat, 3 Oct 2026 14:48:57 +0800
Subject: [PATCH 1/2] style(postgres): fix indentation in validate_privilege

---
 src-tauri/src/database/postgres.rs | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/src-tauri/src/database/postgres.rs b/src-tauri/src/database/postgres.rs
index 55eca291..9f61e809 100644
--- a/src-tauri/src/database/postgres.rs
+++ b/src-tauri/src/database/postgres.rs
@@ -271,18 +271,18 @@ impl PostgresAdapter {
             .join("."))
     }
 
-     fn validate_privilege(privilege: &str) -> DbResult<String> {
-         const PRIVILEGES: &[&str] = &[
-             "SELECT",
-             "INSERT",
-             "UPDATE",
-             "DELETE",
-             "TRUNCATE",
-             "REFERENCES",
-             "TRIGGER",
-             "ALL",
-             "ALL PRIVILEGES",
-         ];
+    fn validate_privilege(privilege: &str) -> DbResult<String> {
+        const PRIVILEGES: &[&str] = &[
+            "SELECT",
+            "INSERT",
+            "UPDATE",
+            "DELETE",
+            "TRUNCATE",
+            "REFERENCES",
+            "TRIGGER",
+            "ALL",
+            "ALL PRIVILEGES",
+        ];
         let mut validated = Vec::new();
         for part in privilege.split(',') {
             let trimmed = part.trim().to_uppercase();

From 263618324313632b3eec594f1c8ea206412098f0 Mon Sep 17 00:00:00 2001
From: blankll <zilisheng1996@gmail.com>
Date: Sat, 3 Oct 2026 14:50:57 +0800
Subject: [PATCH 2/2] feat(duckdb): failure diagnosis, file create/open,
 read-only mode and faster JDBC connects

DuckDB connection UX and transport work, four related streams:

- Failure diagnosis: DuckDB connection failures are translated into an
  explanation with the fix attached (file lock held by another process
  or connection, instance-configuration conflict, storage-format
  incompatibility); the two lock cases offer retry-as-read-only inline
  in the connection form and connecting modal. probe_database_file
  reports the storage-format version and whether a sibling .wal is
  present. scripts/verify-duckdb-jdbc-urls.sh (+ Verify.java) records
  the JDBC URL semantics these decisions rely on.
- Create/open database files from the connection form: editable
  file-based path field with New/Open native dialogs, inline
  explanation of what happens on connect (missing file, empty,
  read-only, folder, wrong engine), per-engine recent files, DuckDB
  File/In-Memory tabs with named in-memory instances (memory:<label>),
  ~ expansion for file paths, and a read-only access mode guarded
  against conflicting access to the same file.
- JDBC speed: the JRE update check is memoised for 6h, a cached driver
  JAR skips Maven resolution, downloads use a shared HTTP client with a
  bounded timeout, the bridge process is shared across connections and
  disconnect releases only its own pool. Warm connect measured ~4.3s ->
  5.5ms with a bridge that also caches the driver class loader
  (duckdb_bridge_integration.rs, #[ignore]-gated).
- Bridge read-only alignment: DuckDB rejects Connection.setReadOnly()
  while HikariCP calls it whenever its flag disagrees, so read-only
  URLs failed; ConnectionManager now derives the HikariCP flag from the
  URL (unit-tested).
- i18n regression guard: a test scans every literal t('...') in src/
  and fails when a key does not resolve in enUS or zhCN; fixes the
  untranslated new-connection menu keys, common.cancel and a missing
  zhCN placeholder it surfaced.
---
 .../java/sqlkit/bridge/ConnectionManager.java |  81 ++-
 .../sqlkit/bridge/ConnectionManagerTest.java  |  24 +
 scripts/duckdb-jdbc-verify/Verify.java        | 164 ++++++
 scripts/verify-duckdb-jdbc-urls.sh            |  32 ++
 src-tauri/src/commands/file_operations.rs     | 326 ++++++++++++
 src-tauri/src/commands/helpers.rs             |   7 +-
 src-tauri/src/database/config.rs              | 109 ++++
 src-tauri/src/database/jdbc_bridge/adapter.rs |  46 +-
 .../src/database/jdbc_bridge/download.rs      | 126 ++++-
 .../src/database/jdbc_bridge/fallback.rs      |  84 ++-
 src-tauri/src/database/jdbc_bridge/jre.rs     |  57 ++
 .../src/database/jdbc_bridge/launcher.rs      |  78 ++-
 src-tauri/src/lib.rs                          |   6 +-
 src-tauri/src/state.rs                        |  75 ++-
 src-tauri/tests/duckdb_bridge_integration.rs  | 147 +++++
 src/__tests__/databaseFiles.test.ts           | 226 ++++++++
 src/__tests__/i18nKeys.test.ts                |  82 +++
 src/components/DeviceReplaceDialog.vue        |   2 +-
 .../connections/ConnectingModal.vue           |   7 +-
 .../connections/DatabaseFileField.vue         | 342 ++++++++++++
 .../connections/ServerFormDialog.vue          | 501 +++++++++++-------
 src/datasources/connectionApi.ts              |   1 +
 src/lang/enUS.ts                              |  51 ++
 src/lang/zhCN.ts                              |  52 ++
 src/store/connectionStore.ts                  |   6 +
 src/utils/databaseFiles.ts                    | 215 ++++++++
 src/utils/duckdbErrors.ts                     | 140 +++++
 27 files changed, 2753 insertions(+), 234 deletions(-)
 create mode 100644 jdbc-bridge/src/test/java/sqlkit/bridge/ConnectionManagerTest.java
 create mode 100644 scripts/duckdb-jdbc-verify/Verify.java
 create mode 100755 scripts/verify-duckdb-jdbc-urls.sh
 create mode 100644 src-tauri/tests/duckdb_bridge_integration.rs
 create mode 100644 src/__tests__/databaseFiles.test.ts
 create mode 100644 src/__tests__/i18nKeys.test.ts
 create mode 100644 src/components/connections/DatabaseFileField.vue
 create mode 100644 src/utils/databaseFiles.ts
 create mode 100644 src/utils/duckdbErrors.ts

diff --git a/jdbc-bridge/src/main/java/sqlkit/bridge/ConnectionManager.java b/jdbc-bridge/src/main/java/sqlkit/bridge/ConnectionManager.java
index 7c0d4764..da0f0339 100644
--- a/jdbc-bridge/src/main/java/sqlkit/bridge/ConnectionManager.java
+++ b/jdbc-bridge/src/main/java/sqlkit/bridge/ConnectionManager.java
@@ -15,6 +15,17 @@ public class ConnectionManager {
     private final Map<String, HikariDataSource> pools = new HashMap<>();
     private final Map<String, DriverClassLoader> loaders = new HashMap<>();
 
+    /**
+     * Driver classes loaded once per JAR set.
+     *
+     * A fresh class loader per connection re-runs the driver's static
+     * initialisation, which for DuckDB maps a ~107 MB native library (measured
+     * ~1.4 s). Caching the loader keeps that cost to the first connection of the
+     * bridge process; entries are released together with the process.
+     */
+    private final Map<String, DriverClassLoader> sharedLoaders = new HashMap<>();
+    private final Map<String, Driver> sharedDrivers = new HashMap<>();
+
     /**
      * Create a new JDBC connection pool.
      *
@@ -49,15 +60,16 @@ public void connect(String connId, String url, String username,
         }
         final String jdbcUrl = url;
 
-        DriverClassLoader loader = new DriverClassLoader(driverJars);
-        Class<?> driverCls = Class.forName(driverClass, true, loader);
-        if (!java.sql.Driver.class.isAssignableFrom(driverCls)) {
-            throw new ClassifiedException("Class " + driverClass + " does not implement java.sql.Driver", null, ErrorClassifier.ErrorType.UNKNOWN);
-        }
-        final java.sql.Driver driver = (java.sql.Driver) driverCls.getDeclaredConstructor().newInstance();
+        final java.sql.Driver driver = sharedDriver(driverClass, driverJars);
+        DriverClassLoader loader = loaderFor(driverJars);
         loaders.put(connId, loader);
 
         HikariConfig config = new HikariConfig();
+        // Keep HikariCP's read-only flag aligned with the connection the driver
+        // already opened: HikariCP calls `connection.setReadOnly(config.isReadOnly())`
+        // whenever the two disagree, and DuckDB rejects changing the mode at
+        // connection level ("Can't change read-only status on connection level").
+        config.setReadOnly(isReadOnlyUrl(jdbcUrl));
         config.setDataSource(new javax.sql.DataSource() {
             public java.sql.Connection getConnection() throws java.sql.SQLException {
                 java.util.Properties info = new java.util.Properties();
@@ -106,6 +118,51 @@ public void setLoginTimeout(int seconds) {}
         pools.put(connId, ds);
     }
 
+    /** Reuse one {@link DriverClassLoader} per set of driver JARs. */
+    private DriverClassLoader loaderFor(List<String> driverJars) throws Exception {
+        String key = String.join("|", driverJars);
+        DriverClassLoader loader = sharedLoaders.get(key);
+        if (loader == null) {
+            loader = new DriverClassLoader(driverJars);
+            sharedLoaders.put(key, loader);
+        }
+        return loader;
+    }
+
+    /** Reuse the instantiated JDBC driver for a driver class + JAR set. */
+    private Driver sharedDriver(String driverClass, List<String> driverJars) throws Exception {
+        String key = driverClass + "|" + String.join("|", driverJars);
+        Driver driver = sharedDrivers.get(key);
+        if (driver != null) {
+            return driver;
+        }
+
+        DriverClassLoader loader = loaderFor(driverJars);
+        Class<?> driverCls = Class.forName(driverClass, true, loader);
+        if (!java.sql.Driver.class.isAssignableFrom(driverCls)) {
+            throw new ClassifiedException("Class " + driverClass + " does not implement java.sql.Driver", null, ErrorClassifier.ErrorType.UNKNOWN);
+        }
+        driver = (java.sql.Driver) driverCls.getDeclaredConstructor().newInstance();
+        sharedDrivers.put(key, driver);
+        return driver;
+    }
+
+    /**
+     * Whether a JDBC URL asks for a read-only database.
+     *
+     * DuckDB expresses this in the URL (`access_mode=READ_ONLY` from SQLKit, or
+     * the driver property `duckdb.read_only`), and the driver refuses to change
+     * the mode through {@link java.sql.Connection#setReadOnly(boolean)}.
+     */
+    static boolean isReadOnlyUrl(String jdbcUrl) {
+        if (jdbcUrl == null) {
+            return false;
+        }
+        String normalized = jdbcUrl.toLowerCase(Locale.ROOT);
+        return normalized.contains("access_mode=read_only")
+                || normalized.contains("duckdb.read_only=true");
+    }
+
     /**
      * Close and remove a connection pool.
      */
@@ -114,10 +171,9 @@ public void disconnect(String connId) {
         if (ds != null) {
             ds.close();
         }
-        DriverClassLoader loader = loaders.remove(connId);
-        if (loader != null) {
-            try { loader.close(); } catch (Exception ignored) { }
-        }
+        // The loader is shared with other connections (see sharedLoaders), so it is
+        // only closed when the whole bridge shuts down.
+        loaders.remove(connId);
     }
 
     /**
@@ -164,5 +220,10 @@ public void closeAll() {
             try { loader.close(); } catch (Exception ignored) { }
         }
         loaders.clear();
+        for (DriverClassLoader loader : sharedLoaders.values()) {
+            try { loader.close(); } catch (Exception ignored) { }
+        }
+        sharedLoaders.clear();
+        sharedDrivers.clear();
     }
 }
diff --git a/jdbc-bridge/src/test/java/sqlkit/bridge/ConnectionManagerTest.java b/jdbc-bridge/src/test/java/sqlkit/bridge/ConnectionManagerTest.java
new file mode 100644
index 00000000..62486fb2
--- /dev/null
+++ b/jdbc-bridge/src/test/java/sqlkit/bridge/ConnectionManagerTest.java
@@ -0,0 +1,24 @@
+package sqlkit.bridge;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ConnectionManagerTest {
+
+    @Test
+    void detectsReadOnlyJdbcUrls() {
+        assertTrue(ConnectionManager.isReadOnlyUrl("/tmp/app.duckdb;access_mode=READ_ONLY"));
+        assertTrue(ConnectionManager.isReadOnlyUrl("jdbc:duckdb:/data/app.duckdb;ACCESS_MODE=read_only"));
+        assertTrue(ConnectionManager.isReadOnlyUrl("jdbc:duckdb:/data/app.duckdb;duckdb.read_only=true"));
+    }
+
+    @Test
+    void treatsEverythingElseAsReadWrite() {
+        assertFalse(ConnectionManager.isReadOnlyUrl("jdbc:duckdb:/data/app.duckdb"));
+        assertFalse(ConnectionManager.isReadOnlyUrl("jdbc:duckdb:memory:shared"));
+        assertFalse(ConnectionManager.isReadOnlyUrl("jdbc:duckdb:/data/app.duckdb;duckdb.read_only=false"));
+        assertFalse(ConnectionManager.isReadOnlyUrl(null));
+    }
+}
diff --git a/scripts/duckdb-jdbc-verify/Verify.java b/scripts/duckdb-jdbc-verify/Verify.java
new file mode 100644
index 00000000..f0b25247
--- /dev/null
+++ b/scripts/duckdb-jdbc-verify/Verify.java
@@ -0,0 +1,164 @@
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Properties;
+
+/**
+ * Verifies the DuckDB JDBC semantics that SQLKit's connection form and JDBC URL
+ * building depend on. Run it with the DuckDB JDBC driver on the classpath:
+ *
+ *   scripts/verify-duckdb-jdbc-urls.sh
+ *
+ * Expectations encoded here (DuckDB 1.5.x):
+ *   - a missing database file is created by the engine on connect
+ *   - `;access_mode=READ_ONLY` works as a URL option and blocks writes
+ *   - the same file opened twice with the SAME configuration shares one instance
+ *   - the same file opened twice with DIFFERENT configurations is rejected
+ *   - a NAMED in-memory instance (`memory:<label>`) is shared between connections,
+ *     while an unnamed one is private to each connection (this is why SQLKit
+ *     stores `memory:<label>` as the host of an in-memory connection)
+ *   - a database path containing `;` cannot be expressed in the JDBC URL at all
+ */
+public class Verify {
+    private static int failures = 0;
+
+    private static void check(String name, boolean ok, String detail) {
+        if (!ok) {
+            failures++;
+        }
+        System.out.println((ok ? "PASS" : "FAIL") + " | " + name + (detail.isEmpty() ? "" : " | " + detail));
+    }
+
+    public static void main(String[] args) throws Exception {
+        Path tmp = Files.createTempDirectory("duckdb-verify");
+        Path cwd = Paths.get("").toAbsolutePath();
+        Class.forName("org.duckdb.DuckDBDriver");
+
+        // 1. A missing file is created by the engine on connect.
+        Path db = tmp.resolve("auto.duckdb");
+        try (Connection c = DriverManager.getConnection("jdbc:duckdb:" + db);
+             Statement s = c.createStatement()) {
+            s.execute("CREATE TABLE t AS SELECT 42 AS x");
+        }
+        check("missing file auto-created on connect", Files.exists(db), "size=" + Files.size(db));
+
+        byte[] header = Files.readAllBytes(db);
+        check("DUCK magic at byte offset 8", new String(header, 8, 4, "US-ASCII").equals("DUCK"), "");
+
+        // 2. URL option: read-only connects and rejects writes.
+        try (Connection ro = DriverManager.getConnection("jdbc:duckdb:" + db + ";access_mode=READ_ONLY");
+             Statement s = ro.createStatement();
+             ResultSet rs = s.executeQuery("SELECT count(*) FROM t")) {
+            rs.next();
+            check("URL option access_mode=READ_ONLY connects", rs.getInt(1) == 1, "count=" + rs.getInt(1));
+            boolean rejected = false;
+            try (Statement w = ro.createStatement()) {
+                w.execute("CREATE TABLE nope AS SELECT 1");
+            } catch (SQLException e) {
+                rejected = true;
+            }
+            check("read-only connection rejects writes", rejected, "");
+        }
+
+        // 3. The equivalent driver property still works as a fallback path.
+        Properties props = new Properties();
+        props.setProperty("duckdb.read_only", "true");
+        try (Connection ignored = DriverManager.getConnection("jdbc:duckdb:" + db, props)) {
+            check("duckdb.read_only property connects", true, "");
+        } catch (SQLException e) {
+            check("duckdb.read_only property connects", false, e.getMessage());
+        }
+
+        // 4. Different configurations for one file in one JVM are rejected; this is
+        //    what the connection form blocks before the engine ever sees it.
+        try (Connection rw = DriverManager.getConnection("jdbc:duckdb:" + db)) {
+            try (Connection ro = DriverManager.getConnection("jdbc:duckdb:" + db + ";access_mode=READ_ONLY")) {
+                check("conflicting configuration rejected", false, "second connection unexpectedly succeeded");
+            } catch (SQLException e) {
+                check("conflicting configuration rejected", true, e.getMessage());
+            }
+        }
+
+        // 5. Same file, same configuration -> one shared in-process instance.
+        try (Connection a = DriverManager.getConnection("jdbc:duckdb:" + db);
+             Connection b = DriverManager.getConnection("jdbc:duckdb:" + db);
+             Statement s = a.createStatement()) {
+            s.execute("CREATE TABLE IF NOT EXISTS shared_rw AS SELECT 1 AS x");
+            try (Statement s2 = b.createStatement();
+                 ResultSet rs = s2.executeQuery("SELECT count(*) FROM shared_rw")) {
+                rs.next();
+                check("same file shares one in-process instance", rs.getInt(1) == 1, "");
+            }
+        }
+
+        // 6. Named in-memory instances are shared across pooled connections.
+        try (Connection a = DriverManager.getConnection("jdbc:duckdb:memory:sqlkit_verify");
+             Connection b = DriverManager.getConnection("jdbc:duckdb:memory:sqlkit_verify");
+             Statement s = a.createStatement()) {
+            s.execute("CREATE TABLE shared_mem AS SELECT 1 AS x");
+            boolean visible = false;
+            try (Statement s2 = b.createStatement();
+                 ResultSet rs = s2.executeQuery("SELECT count(*) FROM shared_mem")) {
+                rs.next();
+                visible = rs.getInt(1) == 1;
+            }
+            check("named memory instance shared across connections", visible, "");
+        }
+
+        // 7. Unnamed in-memory instances are private to a connection: the reason
+        //    SQLKit must never store a bare `:memory:` for a pooled DuckDB pool.
+        try (Connection a = DriverManager.getConnection("jdbc:duckdb:");
+             Connection b = DriverManager.getConnection("jdbc:duckdb:");
+             Statement s = a.createStatement()) {
+            s.execute("CREATE TABLE private_mem AS SELECT 1 AS x");
+            boolean visible = true;
+            try (Statement s2 = b.createStatement();
+                 ResultSet rs = s2.executeQuery("SELECT count(*) FROM private_mem")) {
+                rs.next();
+            } catch (SQLException e) {
+                visible = false;
+            }
+            check("unnamed memory instance is connection-private", !visible, "");
+        }
+
+        // 8. The legacy `:memory:` database value resolves to an in-memory database
+        //    and does not create a literal file.
+        try (Connection c = DriverManager.getConnection("jdbc:duckdb::memory:");
+             Statement s = c.createStatement();
+             ResultSet rs = s.executeQuery("SELECT current_database()")) {
+            rs.next();
+            check("legacy jdbc:duckdb::memory: connects", true, "current_database=" + rs.getString(1));
+        } catch (SQLException e) {
+            check("legacy jdbc:duckdb::memory: connects", false, e.getMessage());
+        }
+        check("no literal ':memory:' file created in cwd", !Files.exists(cwd.resolve(":memory:")), "");
+
+        // 9. A path containing ';' cannot be expressed: the driver splits the URL on
+        //    ';' and reports `Invalid URL entry`. SQLKit rejects such paths.
+        Path semicolon = tmp.resolve("semi;colon.duckdb");
+        boolean semicolonFailed = false;
+        try (Connection ignored = DriverManager.getConnection("jdbc:duckdb:" + semicolon)) {
+            semicolonFailed = false;
+        } catch (SQLException e) {
+            semicolonFailed = true;
+        }
+        check("path containing ';' is unusable in a JDBC URL", semicolonFailed, "");
+
+        Path equals = tmp.resolve("eq=uals.duckdb");
+        try (Connection ignored = DriverManager.getConnection("jdbc:duckdb:" + equals)) {
+            check("path containing '=' opens as a file", Files.exists(equals), "");
+        } catch (SQLException e) {
+            check("path containing '=' opens as a file", false, e.getMessage());
+        }
+
+        System.out.println(failures == 0 ? "ALL CHECKS PASSED" : failures + " CHECK(S) FAILED");
+        if (failures > 0) {
+            System.exit(1);
+        }
+    }
+}
diff --git a/scripts/verify-duckdb-jdbc-urls.sh b/scripts/verify-duckdb-jdbc-urls.sh
new file mode 100755
index 00000000..184e658b
--- /dev/null
+++ b/scripts/verify-duckdb-jdbc-urls.sh
@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+#
+# Verifies the DuckDB JDBC URL / instance semantics that SQLKit's connection
+# form relies on (file auto-creation, read-only, named in-memory instances,
+# configuration conflicts). Requires a JDK 11+ on PATH.
+#
+# Usage: scripts/verify-duckdb-jdbc-urls.sh [driver-version]
+#
+set -euo pipefail
+
+DRIVER_VERSION="${1:-1.5.6.0}"
+GROUP_PATH="org/duckdb/duckdb_jdbc"
+JAR_NAME="duckdb_jdbc-${DRIVER_VERSION}.jar"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+WORK_DIR="${TMPDIR:-/tmp}/sqlkit-duckdb-verify"
+JAR_PATH="${WORK_DIR}/${JAR_NAME}"
+
+if ! command -v java >/dev/null 2>&1; then
+  echo "java is required to run this verification (JDK 11+)" >&2
+  exit 1
+fi
+
+mkdir -p "${WORK_DIR}"
+if [ ! -f "${JAR_PATH}" ]; then
+  echo "Downloading ${JAR_NAME} from Maven Central..."
+  curl -sSL --max-time 600 \
+    -o "${JAR_PATH}" \
+    "https://repo1.maven.org/maven2/${GROUP_PATH}/${DRIVER_VERSION}/${JAR_NAME}"
+fi
+
+echo "Running DuckDB JDBC checks with driver ${DRIVER_VERSION}"
+java -cp "${JAR_PATH}" "${SCRIPT_DIR}/duckdb-jdbc-verify/Verify.java"
diff --git a/src-tauri/src/commands/file_operations.rs b/src-tauri/src/commands/file_operations.rs
index 2aa1a798..b167bc34 100644
--- a/src-tauri/src/commands/file_operations.rs
+++ b/src-tauri/src/commands/file_operations.rs
@@ -314,6 +314,215 @@ pub async fn save_query_metadata(
     write_saved_queries_metadata(app_handle, updated).await
 }
 
+/// Storage format detected from a database file header.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum DatabaseFileFormat {
+    /// DuckDB native format (`DUCK` magic at byte offset 8).
+    Duckdb,
+    /// SQLite format 3 header.
+    Sqlite,
+    /// A file exists but its header matches no known database format.
+    Unknown,
+}
+
+/// Probe result for a file-based database path (SQLite / SQLCipher / DuckDB).
+///
+/// Used by the connection form to explain what will happen on connect: a
+/// missing file is created by the engine, an existing file is opened, and an
+/// existing file of a different format is a likely mistake.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DatabaseFileProbe {
+    /// Tilde-expanded path that was probed.
+    pub path: String,
+    /// Whether the path exists.
+    pub exists: bool,
+    /// Whether the path is a directory (never a valid database file).
+    pub is_directory: bool,
+    /// Size in bytes for regular files.
+    pub size_bytes: Option<u64>,
+    /// Whether the parent directory exists (engines create the file, not the parent).
+    pub parent_exists: bool,
+    /// Whether a probe file could be created and removed in the parent directory.
+    pub parent_writable: bool,
+    /// Whether connects can write: existing file writable, or parent directory writable.
+    pub writable: bool,
+    /// Detected storage format of an existing regular file.
+    pub format: Option<DatabaseFileFormat>,
+    /// DuckDB storage-format version read from the file header (bytes 12..20).
+    ///
+    /// Determines the oldest DuckDB release that can open the file, which is the
+    /// first thing to check when a file "suddenly cannot be opened".
+    pub storage_version: Option<u64>,
+    /// Whether a sibling `<file>.wal` write-ahead log is present.
+    pub has_wal: bool,
+}
+
+const DUCKDB_MAGIC_OFFSET: u64 = 8;
+const DUCKDB_STORAGE_VERSION_OFFSET: usize = 12;
+const DUCKDB_MAGIC: &[u8; 4] = b"DUCK";
+const SQLITE_MAGIC: &[u8; 16] = b"SQLite format 3\0";
+
+/// Detected storage layout of an existing database file.
+struct DatabaseFileHeader {
+    format: DatabaseFileFormat,
+    storage_version: Option<u64>,
+}
+
+/// Read the header of an existing database file: format plus, for DuckDB, the
+/// storage-format version (little-endian `u64` at byte offset 12).
+fn read_database_header(path: &Path) -> DatabaseFileHeader {
+    use std::io::Read;
+
+    let unknown = DatabaseFileHeader {
+        format: DatabaseFileFormat::Unknown,
+        storage_version: None,
+    };
+
+    let Ok(mut file) = fs::File::open(path) else {
+        return unknown;
+    };
+
+    let mut header = Vec::new();
+    if file
+        .by_ref()
+        .take((DUCKDB_STORAGE_VERSION_OFFSET + 8) as u64)
+        .read_to_end(&mut header)
+        .is_err()
+    {
+        return unknown;
+    }
+    if header.len() >= SQLITE_MAGIC.len() && &header[..SQLITE_MAGIC.len()] == SQLITE_MAGIC {
+        return DatabaseFileHeader {
+            format: DatabaseFileFormat::Sqlite,
+            storage_version: None,
+        };
+    }
+
+    let magic_end = DUCKDB_MAGIC_OFFSET as usize + DUCKDB_MAGIC.len();
+    if header.len() >= magic_end && &header[DUCKDB_MAGIC_OFFSET as usize..magic_end] == DUCKDB_MAGIC
+    {
+        let storage_version = header
+            .get(DUCKDB_STORAGE_VERSION_OFFSET..DUCKDB_STORAGE_VERSION_OFFSET + 8)
+            .map(|bytes| {
+                let mut buffer = [0u8; 8];
+                buffer.copy_from_slice(bytes);
+                u64::from_le_bytes(buffer)
+            });
+        return DatabaseFileHeader {
+            format: DatabaseFileFormat::Duckdb,
+            storage_version,
+        };
+    }
+
+    unknown
+}
+
+/// Path of the DuckDB write-ahead log that sits next to a database file.
+fn write_ahead_log_path(path: &Path) -> PathBuf {
+    let mut name = path.as_os_str().to_os_string();
+    name.push(".wal");
+    PathBuf::from(name)
+}
+
+/// Whether an existing file can be opened for writing.
+fn is_file_writable(path: &Path) -> bool {
+    fs::OpenOptions::new().write(true).open(path).is_ok()
+}
+
+/// Whether a file can be created inside `dir`, verified with a temporary probe file.
+fn is_directory_writable(dir: &Path) -> bool {
+    if !dir.is_dir() {
+        return false;
+    }
+    let nanos = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_nanos())
+        .unwrap_or_default();
+    let probe = dir.join(format!(
+        ".sqlkit-write-probe-{}-{}",
+        std::process::id(),
+        nanos
+    ));
+    match fs::OpenOptions::new()
+        .write(true)
+        .create_new(true)
+        .open(&probe)
+    {
+        Ok(_) => {
+            let _ = fs::remove_file(&probe);
+            true
+        }
+        Err(_) => false,
+    }
+}
+
+/// Inspect a file-based database path without creating or modifying it.
+#[tauri::command]
+pub fn probe_database_file(path: String) -> DatabaseFileProbe {
+    let expanded = crate::database::config::expand_tilde(&path);
+    let target = Path::new(&expanded);
+    let metadata = fs::metadata(target).ok();
+
+    let exists = metadata.is_some();
+    let is_directory = metadata.as_ref().map(|m| m.is_dir()).unwrap_or(false);
+    let size_bytes = metadata.as_ref().filter(|m| m.is_file()).map(|m| m.len());
+
+    let parent = match target.parent() {
+        Some(parent) if !parent.as_os_str().is_empty() => parent.to_path_buf(),
+        _ => PathBuf::from("."),
+    };
+    let parent_exists = parent.is_dir();
+    let parent_writable = parent_exists && is_directory_writable(&parent);
+
+    let writable = if exists {
+        !is_directory && is_file_writable(target)
+    } else {
+        parent_writable
+    };
+    let header = if exists && !is_directory {
+        Some(read_database_header(target))
+    } else {
+        None
+    };
+    let format = header.as_ref().map(|h| h.format);
+    let storage_version = header.as_ref().and_then(|h| h.storage_version);
+    let has_wal = write_ahead_log_path(target).is_file();
+
+    DatabaseFileProbe {
+        path: expanded,
+        exists,
+        is_directory,
+        size_bytes,
+        parent_exists,
+        parent_writable,
+        writable,
+        format,
+        storage_version,
+        has_wal,
+    }
+}
+
+/// Create the parent directory of a database file, then re-probe the path.
+///
+/// Engines create a missing database file on connect, but not the directories
+/// leading to it, so the form offers this as an explicit repair action.
+#[tauri::command]
+pub fn create_database_directory(path: String) -> Result<DatabaseFileProbe, String> {
+    let expanded = crate::database::config::expand_tilde(&path);
+    let target = Path::new(&expanded);
+    let parent = match target.parent() {
+        Some(parent) if !parent.as_os_str().is_empty() => parent.to_path_buf(),
+        _ => return Err("The path has no parent directory".to_string()),
+    };
+
+    fs::create_dir_all(&parent)
+        .map_err(|e| format!("Failed to create {}: {}", parent.display(), e))?;
+
+    Ok(probe_database_file(expanded))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -421,4 +630,121 @@ mod tests {
         let content = std::fs::read_to_string(&metadata_path).unwrap();
         let _: SavedQueriesMetadata = serde_json::from_str(&content).unwrap();
     }
+
+    #[test]
+    fn probe_missing_file_reports_creatable_in_existing_directory() {
+        let dir = tempfile::tempdir().unwrap();
+        let target = dir.path().join("new.duckdb");
+
+        let probe = probe_database_file(target.to_string_lossy().to_string());
+
+        assert!(!probe.exists);
+        assert!(!probe.is_directory);
+        assert!(probe.size_bytes.is_none());
+        assert!(probe.parent_exists);
+        assert!(probe.parent_writable);
+        assert!(probe.writable);
+        assert!(probe.format.is_none());
+    }
+
+    #[test]
+    fn probe_missing_file_reports_missing_parent() {
+        let dir = tempfile::tempdir().unwrap();
+        let target = dir.path().join("nested").join("new.duckdb");
+
+        let probe = probe_database_file(target.to_string_lossy().to_string());
+
+        assert!(!probe.exists);
+        assert!(!probe.parent_exists);
+        assert!(!probe.parent_writable);
+        assert!(!probe.writable);
+    }
+
+    #[test]
+    fn probe_detects_duckdb_header_and_storage_version() {
+        let dir = tempfile::tempdir().unwrap();
+        let target = dir.path().join("analytics.duckdb");
+        let mut bytes = vec![0u8; 8];
+        bytes.extend_from_slice(DUCKDB_MAGIC);
+        // Storage version 64, the value duckdb_jdbc 1.5.6 writes for a plain file.
+        bytes.extend_from_slice(&64u64.to_le_bytes());
+        std::fs::write(&target, &bytes).unwrap();
+
+        let probe = probe_database_file(target.to_string_lossy().to_string());
+
+        assert!(probe.exists);
+        assert_eq!(probe.format, Some(DatabaseFileFormat::Duckdb));
+        assert_eq!(probe.storage_version, Some(64));
+        assert!(!probe.has_wal);
+        assert_eq!(probe.size_bytes, Some(bytes.len() as u64));
+        assert!(probe.writable);
+        assert!(probe.parent_exists);
+    }
+
+    #[test]
+    fn probe_reports_a_sibling_write_ahead_log() {
+        let dir = tempfile::tempdir().unwrap();
+        let target = dir.path().join("analytics.duckdb");
+        let mut bytes = vec![0u8; 8];
+        bytes.extend_from_slice(DUCKDB_MAGIC);
+        bytes.extend_from_slice(&64u64.to_le_bytes());
+        std::fs::write(&target, &bytes).unwrap();
+        std::fs::write(write_ahead_log_path(&target), b"wal").unwrap();
+
+        let probe = probe_database_file(target.to_string_lossy().to_string());
+
+        assert!(probe.has_wal);
+    }
+
+    #[test]
+    fn probe_reads_no_storage_version_from_sqlite_files() {
+        let dir = tempfile::tempdir().unwrap();
+        let target = dir.path().join("legacy.db");
+        let mut bytes = SQLITE_MAGIC.to_vec();
+        bytes.extend_from_slice(&[0u8; 64]);
+        std::fs::write(&target, &bytes).unwrap();
+
+        let probe = probe_database_file(target.to_string_lossy().to_string());
+
+        assert_eq!(probe.format, Some(DatabaseFileFormat::Sqlite));
+        assert_eq!(probe.storage_version, None);
+    }
+
+    #[test]
+    fn probe_detects_sqlite_header() {
+        let dir = tempfile::tempdir().unwrap();
+        let target = dir.path().join("legacy.db");
+        let mut bytes = SQLITE_MAGIC.to_vec();
+        bytes.extend_from_slice(&[0u8; 64]);
+        std::fs::write(&target, &bytes).unwrap();
+
+        let probe = probe_database_file(target.to_string_lossy().to_string());
+
+        assert_eq!(probe.format, Some(DatabaseFileFormat::Sqlite));
+    }
+
+    #[test]
+    fn probe_flags_unknown_format() {
+        let dir = tempfile::tempdir().unwrap();
+        let target = dir.path().join("notes.txt");
+        std::fs::write(&target, b"definitely not a database").unwrap();
+
+        let probe = probe_database_file(target.to_string_lossy().to_string());
+
+        assert_eq!(probe.format, Some(DatabaseFileFormat::Unknown));
+    }
+
+    #[test]
+    fn probe_rejects_directories() {
+        let dir = tempfile::tempdir().unwrap();
+        let target = dir.path().join("folder");
+        std::fs::create_dir(&target).unwrap();
+
+        let probe = probe_database_file(target.to_string_lossy().to_string());
+
+        assert!(probe.exists);
+        assert!(probe.is_directory);
+        assert!(!probe.writable);
+        assert!(probe.format.is_none());
+    }
 }
diff --git a/src-tauri/src/commands/helpers.rs b/src-tauri/src/commands/helpers.rs
index efa5ab7a..4f7e93aa 100644
--- a/src-tauri/src/commands/helpers.rs
+++ b/src-tauri/src/commands/helpers.rs
@@ -119,7 +119,12 @@ pub async fn test_connection(
         ConnectionStrategy::JdbcBridge => {
             let mut adapter = JdbcBridgeAdapter::new(conn_config);
             adapter.connect().await.map_err(|e| e.to_string())?;
-            adapter.test_connection().await.map_err(|e| e.to_string())
+            let status = adapter.test_connection().await.map_err(|e| e.to_string());
+            // Close the pool explicitly: the bridge process is shared, so a pooled
+            // connection left behind would hold the database (and a DuckDB file
+            // lock) open until the app exits.
+            let _ = adapter.disconnect().await;
+            status
         }
         ConnectionStrategy::Http => match dt {
             DatabaseType::RQLite => {
diff --git a/src-tauri/src/database/config.rs b/src-tauri/src/database/config.rs
index 77b4410a..8737b57b 100644
--- a/src-tauri/src/database/config.rs
+++ b/src-tauri/src/database/config.rs
@@ -414,6 +414,50 @@ impl ConnectionConfig {
     }
 }
 
+/// Expand a leading `~` to the current user's home directory.
+///
+/// File-based engines pass the path straight to the driver, which does not
+/// expand shell short-hands, so `~/data/app.duckdb` would otherwise create a
+/// literal `~` directory next to the process working directory.
+pub fn expand_tilde(path: &str) -> String {
+    let trimmed = path.trim();
+    let home = std::env::var("HOME").or_else(|_| std::env::var("USERPROFILE"));
+    match home {
+        Ok(home) if trimmed == "~" => home,
+        Ok(home) if trimmed.starts_with("~/") || trimmed.starts_with("~\\") => {
+            format!("{}{}", home, &trimmed[1..])
+        }
+        _ => trimmed.to_string(),
+    }
+}
+
+/// Build the `{database}` component of the DuckDB JDBC URL template
+/// (`jdbc:duckdb:{database}`).
+///
+/// DuckDB accepts JDBC URL options after the database part, so read-only mode is
+/// expressed as `access_mode=READ_ONLY`. Paths are tilde-expanded because the
+/// driver treats the value literally.
+///
+/// The driver splits the URL on `;` before opening the database (verified
+/// against `duckdb_jdbc` 1.5.6: `semi;colon.duckdb` fails with
+/// `Invalid URL entry`), so such paths are rejected instead of being silently
+/// turned into options — or, worse, into a read-write connection when the user
+/// asked for read-only.
+pub fn duckdb_database_value(host: &str, read_only: bool) -> Result<String, String> {
+    let path = expand_tilde(host);
+    if path.contains(';') {
+        return Err(
+            "DuckDB's JDBC driver splits the connection URL on ';', so a database path \
+             containing ';' cannot be opened. Rename the file and try again."
+                .to_string(),
+        );
+    }
+    if !read_only {
+        return Ok(path);
+    }
+    Ok(format!("{};access_mode=READ_ONLY", path))
+}
+
 /// Serialization helpers for Duration.
 mod duration_serde {
     use serde::{Deserialize, Deserializer, Serializer};
@@ -434,3 +478,68 @@ mod duration_serde {
         Ok(Duration::from_secs(secs))
     }
 }
+
+#[cfg(test)]
+mod file_path_tests {
+    use super::*;
+
+    #[test]
+    fn expand_tilde_leaves_plain_paths_untouched() {
+        assert_eq!(expand_tilde("/tmp/app.duckdb"), "/tmp/app.duckdb");
+        assert_eq!(expand_tilde(":memory:"), ":memory:");
+        assert_eq!(expand_tilde("  /tmp/app.duckdb  "), "/tmp/app.duckdb");
+    }
+
+    #[test]
+    fn expand_tilde_replaces_leading_home() {
+        let home = std::env::var("HOME").or_else(|_| std::env::var("USERPROFILE"));
+        let Ok(home) = home else {
+            return;
+        };
+        assert_eq!(
+            expand_tilde("~/data/app.duckdb"),
+            format!("{}/data/app.duckdb", home)
+        );
+        assert_eq!(expand_tilde("~"), home);
+    }
+
+    #[test]
+    fn duckdb_database_value_appends_read_only_option() {
+        assert_eq!(
+            duckdb_database_value("/tmp/app.duckdb", false),
+            Ok("/tmp/app.duckdb".to_string())
+        );
+        assert_eq!(
+            duckdb_database_value("/tmp/app.duckdb", true),
+            Ok("/tmp/app.duckdb;access_mode=READ_ONLY".to_string())
+        );
+    }
+
+    #[test]
+    fn duckdb_database_value_keeps_named_memory_instances() {
+        assert_eq!(
+            duckdb_database_value("memory:sqlkit_ab12cd34", false),
+            Ok("memory:sqlkit_ab12cd34".to_string())
+        );
+        assert_eq!(
+            duckdb_database_value("memory:sqlkit_ab12cd34", true),
+            Ok("memory:sqlkit_ab12cd34;access_mode=READ_ONLY".to_string())
+        );
+    }
+
+    #[test]
+    fn duckdb_database_value_rejects_pre_joined_options() {
+        // Callers pass a bare path; a value that already carries URL options is
+        // rejected so options can never be applied twice by accident.
+        let once = duckdb_database_value("/tmp/app.duckdb", true).expect("value");
+        assert!(duckdb_database_value(&once, true).is_err());
+    }
+
+    #[test]
+    fn duckdb_database_value_rejects_paths_with_semicolons() {
+        // Verified against duckdb_jdbc 1.5.6: `jdbc:duckdb:/tmp/semi;colon.duckdb`
+        // fails with `Invalid URL entry: colon.duckdb`.
+        assert!(duckdb_database_value("/tmp/semi;colon.duckdb", false).is_err());
+        assert!(duckdb_database_value("/tmp/semi;colon.duckdb", true).is_err());
+    }
+}
diff --git a/src-tauri/src/database/jdbc_bridge/adapter.rs b/src-tauri/src/database/jdbc_bridge/adapter.rs
index 65f67aea..c0b08991 100644
--- a/src-tauri/src/database/jdbc_bridge/adapter.rs
+++ b/src-tauri/src/database/jdbc_bridge/adapter.rs
@@ -160,9 +160,19 @@ impl DatabaseAdapter for JdbcBridgeAdapter {
     }
 
     async fn disconnect(&mut self) -> DbResult<()> {
-        if let Some(launcher) = &self.launcher {
-            let mut guard = launcher.lock().await;
-            guard.shutdown();
+        // Release only this connection's pool. The bridge process is shared with
+        // other connections, and `disconnect` is what closes the HikariCP pool —
+        // which in turn releases DuckDB's exclusive file lock.
+        if let (Some(launcher), Some(conn_id)) = (self.launcher.clone(), self.conn_id.clone()) {
+            let request = JdbcRequest::new(
+                JdbcMethod::Disconnect,
+                serde_json::json!({ "conn_id": conn_id }),
+            );
+            let _ = tokio::time::timeout(std::time::Duration::from_secs(10), async {
+                let mut guard = launcher.lock().await;
+                guard.send_request(&request)
+            })
+            .await;
         }
         self.launcher = None;
         self.conn_id = None;
@@ -576,3 +586,33 @@ mod tests {
         assert_eq!(stmts[1], "SELECT 2");
     }
 }
+
+impl Drop for JdbcBridgeAdapter {
+    /// Best-effort pool release for adapters dropped without `disconnect()`.
+    ///
+    /// The bridge process outlives single connections now, so a leaked pool would
+    /// keep the database open (and a DuckDB file locked) for the rest of the
+    /// session. The "Test connection" path is the main caller of this.
+    fn drop(&mut self) {
+        let (Some(launcher), Some(conn_id)) = (self.launcher.take(), self.conn_id.take()) else {
+            return;
+        };
+
+        let request = JdbcRequest::new(
+            JdbcMethod::Disconnect,
+            serde_json::json!({ "conn_id": conn_id }),
+        );
+
+        if let Ok(mut guard) = launcher.try_lock() {
+            let _ = guard.send_request(&request);
+            return;
+        }
+
+        if let Ok(handle) = tokio::runtime::Handle::try_current() {
+            handle.spawn(async move {
+                let mut guard = launcher.lock().await;
+                let _ = guard.send_request(&request);
+            });
+        }
+    }
+}
diff --git a/src-tauri/src/database/jdbc_bridge/download.rs b/src-tauri/src/database/jdbc_bridge/download.rs
index 4090a783..c93058b1 100644
--- a/src-tauri/src/database/jdbc_bridge/download.rs
+++ b/src-tauri/src/database/jdbc_bridge/download.rs
@@ -6,11 +6,14 @@
 //! JDBC driver JARs can be downloaded directly from Maven Central
 //! (fallback if the Java bridge resolution is unavailable).
 
+use super::registry::DatabaseDriverConfig;
 use crate::database::error::{DbError, DbResult};
 use crate::download::DownloadKind;
 use futures::StreamExt;
 use std::path::{Path, PathBuf};
 use std::process::Command;
+use std::sync::OnceLock;
+use std::time::Duration;
 
 const APP_VERSION: &str = env!("APP_VERSION");
 
@@ -41,6 +44,63 @@ pub fn is_bridge_installed() -> bool {
     bridge_jar_path().exists()
 }
 
+/// Upper bound for Maven metadata requests. Without one, a stalled endpoint
+/// keeps `test_connection` spinning with no way out.
+const METADATA_TIMEOUT: Duration = Duration::from_secs(20);
+
+/// Shared HTTP client with a bounded connection setup.
+///
+/// `reqwest::get` builds a client without any timeout, so a network that accepts
+/// the TCP connection but never answers used to hang bridge setup forever.
+fn http_client() -> &'static reqwest::Client {
+    static CLIENT: OnceLock<reqwest::Client> = OnceLock::new();
+    CLIENT.get_or_init(|| {
+        reqwest::Client::builder()
+            .connect_timeout(Duration::from_secs(15))
+            .build()
+            .unwrap_or_default()
+    })
+}
+
+/// Directory holding the cached driver JARs of one Maven artifact.
+pub fn driver_cache_dir(artifact: &str) -> PathBuf {
+    bridge_dir().join("drivers").join(artifact)
+}
+
+/// Newest `.jar` inside `dir`, ignoring anything that is not a regular file.
+fn newest_jar_in(dir: &Path) -> Option<PathBuf> {
+    std::fs::read_dir(dir)
+        .ok()?
+        .flatten()
+        .filter(|entry| entry.path().is_file())
+        .filter(|entry| entry.path().extension().is_some_and(|ext| ext == "jar"))
+        .filter_map(|entry| {
+            let modified = entry.metadata().ok()?.modified().ok()?;
+            Some((modified, entry.path()))
+        })
+        .max_by_key(|(modified, _)| *modified)
+        .map(|(_, path)| path)
+}
+
+/// Newest cached driver JAR for a Maven artifact, if one was downloaded before.
+pub fn newest_cached_driver_jar(artifact: &str) -> Option<PathBuf> {
+    newest_jar_in(&driver_cache_dir(artifact))
+}
+
+/// Cached JAR to use for a driver config without touching the network.
+///
+/// A registry `version_cap` pins the exact file to use; uncapped artifacts
+/// (DuckDB, for example) take the newest JAR already in the cache, which is what
+/// the explicit "update driver" action would replace.
+pub fn cached_driver_jar(config: &DatabaseDriverConfig) -> Option<PathBuf> {
+    if let Some(cap) = &config.version_cap {
+        let pinned = driver_cache_dir(&config.maven_artifact)
+            .join(format!("{}-{}.jar", config.maven_artifact, cap));
+        return pinned.is_file().then_some(pinned);
+    }
+    newest_cached_driver_jar(&config.maven_artifact)
+}
+
 /// Download a file from URL to a temporary path, then atomically rename to final.
 /// Emits Tauri progress events if the global APP_HANDLE is set.
 pub async fn download_to_path(
@@ -51,7 +111,9 @@ pub async fn download_to_path(
     expected_size_hint: u64,
 ) -> DbResult<()> {
     let tmp_path = dest.with_extension("tmp");
-    let response = reqwest::get(url)
+    let response = http_client()
+        .get(url)
+        .send()
         .await
         .map_err(|e| DbError::Connection(format!("Failed to download from {}: {}", url, e)))?;
     if !response.status().is_success() {
@@ -216,11 +278,15 @@ pub async fn download_jdbc_driver_direct(db_type: &str) -> DbResult<()> {
         DbError::Connection(format!("No driver registry entry for '{}'", db_type))
     })?;
 
-    let dest_dir = super::jre::home_dir()
-        .join(".sqlkit")
-        .join("jdbc-bridge")
-        .join("drivers")
-        .join(&config.maven_artifact);
+    let dest_dir = driver_cache_dir(&config.maven_artifact);
+
+    // Anything already cached is good enough for the pre-flight check — resolving
+    // LATEST over the network is what made every DuckDB "Test connection" pay a
+    // Maven round trip even though the JAR was on disk. Use the explicit driver
+    // update action to move to a newer version.
+    if cached_driver_jar(config).is_some() {
+        return Ok(());
+    }
 
     // Drivers with a direct download URL (non-Maven, e.g. GBase 8a)
     if let Some(download_url) = &config.download_url {
@@ -248,7 +314,10 @@ pub async fn download_jdbc_driver_direct(db_type: &str) -> DbResult<()> {
             "https://repo1.maven.org/maven2/{}/{}/maven-metadata.xml",
             group_path, config.maven_artifact
         );
-        let resp = reqwest::get(&metadata_url)
+        let resp = http_client()
+            .get(&metadata_url)
+            .timeout(METADATA_TIMEOUT)
+            .send()
             .await
             .map_err(|e| DbError::Connection(format!("Failed to fetch Maven metadata: {}", e)))?;
         if !resp.status().is_success() {
@@ -335,3 +404,46 @@ async fn cleanup_old_bridge_versions() -> DbResult<()> {
     }
     Ok(())
 }
+
+#[cfg(test)]
+mod driver_cache_tests {
+    use super::*;
+
+    fn write_jar(dir: &Path, name: &str, modified: std::time::SystemTime) {
+        std::fs::create_dir_all(dir).unwrap();
+        let path = dir.join(name);
+        std::fs::write(&path, b"jar").unwrap();
+        std::fs::File::options()
+            .write(true)
+            .open(&path)
+            .unwrap()
+            .set_modified(modified)
+            .unwrap();
+    }
+
+    #[test]
+    fn newest_jar_in_picks_the_latest_jar_only() {
+        let dir = tempfile::tempdir().unwrap();
+        let now = std::time::SystemTime::now();
+        write_jar(
+            dir.path(),
+            "duckdb_jdbc-1.4.0.0.jar",
+            now - Duration::from_secs(600),
+        );
+        write_jar(dir.path(), "duckdb_jdbc-1.5.6.0.jar", now);
+        write_jar(dir.path(), "unrelated.zip", now + Duration::from_secs(600));
+
+        let newest = newest_jar_in(dir.path()).expect("cached jar");
+        assert_eq!(
+            newest.file_name().unwrap().to_string_lossy(),
+            "duckdb_jdbc-1.5.6.0.jar"
+        );
+    }
+
+    #[test]
+    fn newest_jar_in_returns_none_for_empty_or_missing_dirs() {
+        let dir = tempfile::tempdir().unwrap();
+        assert!(newest_jar_in(dir.path()).is_none());
+        assert!(newest_jar_in(&dir.path().join("missing")).is_none());
+    }
+}
diff --git a/src-tauri/src/database/jdbc_bridge/fallback.rs b/src-tauri/src/database/jdbc_bridge/fallback.rs
index 60c4729d..68720d26 100644
--- a/src-tauri/src/database/jdbc_bridge/fallback.rs
+++ b/src-tauri/src/database/jdbc_bridge/fallback.rs
@@ -117,17 +117,44 @@ pub async fn try_driver(
 ) -> DriverAttempt {
     let url = build_oracle_url(config, host, port, database, oracle_options);
 
-    // Start bridge (no driver JARs yet — ResolveDriver will download on the Java side)
+    // Reuse the app-wide bridge process: a fresh JVM would re-map DuckDB's
+    // ~107 MB native library (~1.4 s) on every single connection attempt.
     let bridge_jar = download::bridge_jar_path();
-    let mut launcher = JdbcBridgeLauncher::new(bridge_jar);
     let jvm_args = build_jvm_args(oracle_options);
-    match launcher.start(&jvm_args) {
-        Ok(_) => {}
+    let launcher = match super::launcher::shared_launcher(&bridge_jar, &jvm_args) {
+        Ok(launcher) => launcher,
         Err(e) => return DriverAttempt::Fatal(e),
+    };
+
+    // Step 1: ResolveDriver — let the Java bridge download / resolve the driver JAR.
+    // A cached JAR short-circuits the RPC (and with it a Maven metadata request on
+    // the Java side). Artifacts with a version cap keep the original
+    // latest-then-cap fallback behaviour.
+    let cached_jar = if config.version_cap.is_none() {
+        download::cached_driver_jar(config)
+    } else {
+        None
+    };
+
+    if let Some(cached) = cached_jar {
+        return connect_with_jar(
+            &launcher,
+            config,
+            cached.to_string_lossy().to_string(),
+            url,
+            username,
+            password,
+            database,
+            oracle_options,
+            ssl_mode,
+            ssl_ca_cert,
+            ssl_client_cert,
+            ssl_client_key,
+            trust_server_certificate,
+        )
+        .await;
     }
-    let launcher = Arc::new(Mutex::new(launcher));
 
-    // Step 1: ResolveDriver — let the Java bridge download / resolve the driver JAR
     // On the first attempt, try without version_cap (LATEST).
     // If the config has no cap, or we're explicitly using it, send the cap.
     let effective_cap = if use_cap {
@@ -189,6 +216,41 @@ pub async fn try_driver(
         }
     };
 
+    connect_with_jar(
+        &launcher,
+        config,
+        jar_path,
+        url,
+        username,
+        password,
+        database,
+        oracle_options,
+        ssl_mode,
+        ssl_ca_cert,
+        ssl_client_cert,
+        ssl_client_key,
+        trust_server_certificate,
+    )
+    .await
+}
+
+/// Send the `Connect` RPC for an already resolved driver JAR.
+#[allow(clippy::too_many_arguments)]
+async fn connect_with_jar(
+    launcher: &Arc<Mutex<JdbcBridgeLauncher>>,
+    config: &DatabaseDriverConfig,
+    jar_path: String,
+    url: String,
+    username: &str,
+    password: &Option<String>,
+    database: Option<&str>,
+    oracle_options: Option<&OracleConnectionOptions>,
+    ssl_mode: Option<&str>,
+    ssl_ca_cert: Option<&str>,
+    ssl_client_cert: Option<&str>,
+    ssl_client_key: Option<&str>,
+    trust_server_certificate: bool,
+) -> DriverAttempt {
     // Step 2: Send connect request with the resolved JAR on the classpath
     let params = match serde_json::to_value(ConnectParams {
         url,
@@ -238,7 +300,7 @@ pub async fn try_driver(
                         DriverAttempt::VersionMismatch(err.clone())
                     }
                     _ => {
-                        let stderr = stderr_from_launcher(&launcher);
+                        let stderr = stderr_from_launcher(launcher);
                         let detail = if stderr.is_empty() {
                             err.clone()
                         } else {
@@ -252,11 +314,11 @@ pub async fn try_driver(
                     .result
                     .and_then(|v| v.as_str().map(|s| s.to_string()))
                     .unwrap_or_else(|| format!("conn_{}", uuid::Uuid::new_v4()));
-                DriverAttempt::Connected(conn_id, launcher)
+                DriverAttempt::Connected(conn_id, launcher.clone())
             }
         }
         Ok(Err(e)) => {
-            let stderr = stderr_from_launcher(&launcher);
+            let stderr = stderr_from_launcher(launcher);
             let msg = if stderr.is_empty() {
                 e.to_string()
             } else {
@@ -335,7 +397,9 @@ pub async fn run_fallback_chain(
             }
         }
     } else {
-        if let Some(redirect_url) = super::jre::check_adoptium_update().await {
+        // Memoised: this used to be a blocking HTTP round trip (1.4-2.5 s) before
+        // every single connect, including local DuckDB/SQLite-style files.
+        if let Some(redirect_url) = super::jre::check_adoptium_update_cached().await {
             if let Some(latest) = super::jre::parse_adoptium_build_version(&redirect_url) {
                 if let Some(current) = super::jre::read_jre_version() {
                     if super::jre::compare_versions(&latest, &current) > 0 {
diff --git a/src-tauri/src/database/jdbc_bridge/jre.rs b/src-tauri/src/database/jdbc_bridge/jre.rs
index 8bd6dac6..d67f4b8b 100644
--- a/src-tauri/src/database/jdbc_bridge/jre.rs
+++ b/src-tauri/src/database/jdbc_bridge/jre.rs
@@ -247,6 +247,38 @@ pub fn read_jre_version() -> Option<String> {
 
 // ── Adoptium update check ─────────────────────────────────
 
+/// How long an Adoptium update answer is reused.
+///
+/// The check follows a redirect through Adoptium's CDN and measured 1.4–2.5 s
+/// per call. It used to run before *every* JDBC connect, which made a cached,
+/// local DuckDB connection feel like a network connection.
+const UPDATE_CHECK_TTL: std::time::Duration = std::time::Duration::from_secs(6 * 60 * 60);
+
+/// Memoised Adoptium update check: `(checked_at, redirect_url)`.
+static UPDATE_CHECK_CACHE: OnceLock<
+    std::sync::Mutex<Option<(std::time::Instant, Option<String>)>>,
+> = OnceLock::new();
+
+/// Memoised variant of [`check_adoptium_update`] with a TTL, so a burst of
+/// connects only pays for one update check.
+pub async fn check_adoptium_update_cached() -> Option<String> {
+    let cache = UPDATE_CHECK_CACHE.get_or_init(|| std::sync::Mutex::new(None));
+
+    if let Ok(guard) = cache.lock() {
+        if let Some((checked_at, result)) = guard.as_ref() {
+            if checked_at.elapsed() < UPDATE_CHECK_TTL {
+                return result.clone();
+            }
+        }
+    }
+
+    let result = check_adoptium_update().await;
+    if let Ok(mut guard) = cache.lock() {
+        *guard = Some((std::time::Instant::now(), result.clone()));
+    }
+    result
+}
+
 /// Check if a newer JRE build is available from Adoptium.
 ///
 /// Returns `Some(redirect_url)` with the redirect target containing the build
@@ -632,3 +664,28 @@ mod tests {
         assert!(system_java_version(&current).is_none());
     }
 }
+
+#[cfg(test)]
+mod update_check_tests {
+    use super::*;
+
+    #[test]
+    fn update_check_cache_reuses_fresh_results() {
+        let cache = std::sync::Mutex::new(Some((
+            std::time::Instant::now(),
+            Some("https://example.invalid/jre.tar.gz".to_string()),
+        )));
+
+        let (checked_at, result) = cache.lock().unwrap().clone().unwrap();
+        assert!(checked_at.elapsed() < UPDATE_CHECK_TTL);
+        assert_eq!(
+            result.as_deref(),
+            Some("https://example.invalid/jre.tar.gz")
+        );
+    }
+
+    #[test]
+    fn update_check_ttl_is_hours_not_seconds() {
+        assert!(UPDATE_CHECK_TTL >= std::time::Duration::from_secs(3600));
+    }
+}
diff --git a/src-tauri/src/database/jdbc_bridge/launcher.rs b/src-tauri/src/database/jdbc_bridge/launcher.rs
index 16e8c610..16926049 100644
--- a/src-tauri/src/database/jdbc_bridge/launcher.rs
+++ b/src-tauri/src/database/jdbc_bridge/launcher.rs
@@ -4,10 +4,11 @@
 //! JSON over stdin/stdout.
 
 use crate::database::error::{DbError, DbResult};
+use std::collections::HashMap;
 use std::io::{BufRead, BufReader, Write};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::process::{Child, ChildStdin, Command, Stdio};
-use std::sync::{Arc, Mutex};
+use std::sync::{Arc, Mutex, OnceLock};
 use std::thread;
 
 use super::protocol::{JdbcRequest, JdbcResponse};
@@ -486,6 +487,10 @@ impl JdbcBridgeLauncher {
     }
 
     /// Shutdown the bridge process gracefully.
+    ///
+    /// Only belongs to the shared registry owner: connections must release their
+    /// own pool through the `disconnect` RPC (`JdbcMethod::Disconnect`) instead,
+    /// because other connections may be served by the same process.
     pub fn shutdown(&mut self) {
         if let Some(mut child) = self.process.take() {
             let _ = child.kill();
@@ -496,6 +501,75 @@ impl JdbcBridgeLauncher {
     }
 }
 
+/// Bridge processes shared across connections, keyed by JAR + JVM options.
+type LauncherRegistry = Mutex<HashMap<String, Arc<tokio::sync::Mutex<JdbcBridgeLauncher>>>>;
+
+fn launcher_registry() -> &'static LauncherRegistry {
+    static REGISTRY: OnceLock<LauncherRegistry> = OnceLock::new();
+    REGISTRY.get_or_init(|| Mutex::new(HashMap::new()))
+}
+
+/// Key of a reusable bridge process configuration.
+///
+/// JVM options are part of the key because they cannot change once the process
+/// is running (Oracle wallet/keystore arguments, for example).
+fn launcher_key(bridge_jar: &Path, jvm_args: &[String]) -> String {
+    format!("{}::{}", bridge_jar.display(), jvm_args.join(" "))
+}
+
+/// Get the bridge JVM shared by every connection with the same JAR and options,
+/// starting one when none is alive.
+///
+/// Starting a JVM is cheap, but the first JDBC connection inside it is not:
+/// DuckDB's driver maps a ~107 MB native library (measured ~1.4 s), and the
+/// driver resolution also reaches Maven Central. Sharing the process pays both
+/// costs once per app session instead of once per connection or "Test".
+pub fn shared_launcher(
+    bridge_jar: &Path,
+    jvm_args: &[String],
+) -> DbResult<Arc<tokio::sync::Mutex<JdbcBridgeLauncher>>> {
+    let key = launcher_key(bridge_jar, jvm_args);
+    let mut registry = launcher_registry()
+        .lock()
+        .unwrap_or_else(|poisoned| poisoned.into_inner());
+
+    if let Some(existing) = registry.get(&key) {
+        let alive = match existing.try_lock() {
+            Ok(mut guard) => guard.is_alive(),
+            // Busy means another request is in flight, so the process is alive.
+            Err(_) => true,
+        };
+        if alive {
+            return Ok(existing.clone());
+        }
+    }
+
+    let mut launcher = JdbcBridgeLauncher::new(bridge_jar.to_path_buf());
+    launcher.start(jvm_args)?;
+    let shared = Arc::new(tokio::sync::Mutex::new(launcher));
+    registry.insert(key, shared.clone());
+    Ok(shared)
+}
+
+#[cfg(test)]
+mod launcher_registry_tests {
+    use super::*;
+
+    #[test]
+    fn launcher_key_separates_jars_and_jvm_options() {
+        let jar = PathBuf::from("/tmp/jdbc-bridge-0.8.8.jar");
+        assert_eq!(launcher_key(&jar, &[]), launcher_key(&jar, &[]),);
+        assert_ne!(
+            launcher_key(&jar, &[]),
+            launcher_key(&jar, &["-Dfoo=bar".to_string()]),
+        );
+        assert_ne!(
+            launcher_key(&jar, &[]),
+            launcher_key(Path::new("/tmp/other.jar"), &[]),
+        );
+    }
+}
+
 impl Drop for JdbcBridgeLauncher {
     fn drop(&mut self) {
         self.shutdown();
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 69fce99f..88c7796f 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -227,7 +227,9 @@ pub fn run() {
                 if let Ok(urls) = serde_json::from_str::<Vec<String>>(event.payload()) {
                     for url in &urls {
                         if let Some(payload) = parse_auth_from_url(url) {
-                            app_handle.state::<PendingAuthState>().store(payload.clone());
+                            app_handle
+                                .state::<PendingAuthState>()
+                                .store(payload.clone());
                             let _ = app_handle.emit("sqlkit://auth", payload);
                         }
                     }
@@ -362,6 +364,8 @@ pub fn run() {
             commands::read_saved_queries_metadata,
             commands::write_saved_queries_metadata,
             commands::save_query_metadata,
+            commands::probe_database_file,
+            commands::create_database_directory,
             commands::preview_export_data,
             commands::execute_export_data,
             commands::detect_file_format,
diff --git a/src-tauri/src/state.rs b/src-tauri/src/state.rs
index d0df29f9..ce788956 100644
--- a/src-tauri/src/state.rs
+++ b/src-tauri/src/state.rs
@@ -87,6 +87,12 @@ pub struct ServerConfig {
     /// Transport layer configuration (SSH tunnels).
     #[serde(skip_serializing_if = "Option::is_none")]
     pub transport_layers: Option<Vec<TransportLayerConfig>>,
+    /// Open the local database file read-only (DuckDB currently).
+    ///
+    /// Read-only is the only way for several processes to share a DuckDB file,
+    /// because a read-write instance holds an exclusive file lock.
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub read_only: bool,
 }
 
 fn default_timeout_10() -> u64 {
@@ -125,6 +131,7 @@ impl ServerConfig {
             connect_timeout_secs: default_timeout_10(),
             query_timeout_secs: default_timeout_30(),
             transport_layers: None,
+            read_only: false,
         }
     }
 
@@ -214,13 +221,15 @@ impl ServerConfig {
         }
 
         let db_lower = self.db_type.to_lowercase();
-        // SQLite, SQLCipher, and DuckDB are file-based
-        if db_lower == "sqlite"
-            || db_lower == "sqlcipher"
-            || db_lower == "duckdb"
-            || db_lower == "duck"
-        {
-            config = config.with_database(&self.host);
+        // SQLite, SQLCipher, and DuckDB are file-based: the UI keeps the path in
+        // `host`, while the adapters and the JDBC URL builder read `database`.
+        if db_lower == "sqlite" || db_lower == "sqlcipher" {
+            config = config.with_database(crate::database::config::expand_tilde(&self.host));
+        } else if db_lower == "duckdb" || db_lower == "duck" {
+            let database =
+                crate::database::config::duckdb_database_value(&self.host, self.read_only)
+                    .map_err(|e| format!("Invalid DuckDB database path: {}", e))?;
+            config = config.with_database(database);
         } else if let Some(ref database) = self.database {
             config = config.with_database(database);
         }
@@ -363,3 +372,55 @@ impl Default for AppState {
         Self::new()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn file_config(db_type: &str, host: &str, read_only: bool) -> ServerConfig {
+        let mut config = ServerConfig::new(
+            "local".to_string(),
+            db_type.to_string(),
+            host.to_string(),
+            0,
+            String::new(),
+        );
+        config.read_only = read_only;
+        config
+    }
+
+    #[test]
+    fn duckdb_maps_the_file_path_into_the_database_field() {
+        let config = file_config("duckdb", "/tmp/analytics.duckdb", false)
+            .to_connection_config()
+            .expect("config");
+        assert_eq!(config.database.as_deref(), Some("/tmp/analytics.duckdb"));
+    }
+
+    #[test]
+    fn duckdb_read_only_appends_access_mode_to_the_jdbc_database() {
+        let config = file_config("duckdb", "/tmp/analytics.duckdb", true)
+            .to_connection_config()
+            .expect("config");
+        assert_eq!(
+            config.database.as_deref(),
+            Some("/tmp/analytics.duckdb;access_mode=READ_ONLY")
+        );
+    }
+
+    #[test]
+    fn duckdb_named_memory_instance_is_preserved() {
+        let config = file_config("duckdb", "memory:sqlkit_shared", false)
+            .to_connection_config()
+            .expect("config");
+        assert_eq!(config.database.as_deref(), Some("memory:sqlkit_shared"));
+    }
+
+    #[test]
+    fn sqlite_keeps_memory_sentinel_and_never_gets_duckdb_options() {
+        let config = file_config("sqlite", ":memory:", true)
+            .to_connection_config()
+            .expect("config");
+        assert_eq!(config.database.as_deref(), Some(":memory:"));
+    }
+}
diff --git a/src-tauri/tests/duckdb_bridge_integration.rs b/src-tauri/tests/duckdb_bridge_integration.rs
new file mode 100644
index 00000000..ebf684ac
--- /dev/null
+++ b/src-tauri/tests/duckdb_bridge_integration.rs
@@ -0,0 +1,147 @@
+//! Integration tests for the shared JDBC bridge process with DuckDB.
+//!
+//! These tests exercise the real Java bridge, so they require:
+//! - Java 25+ on the machine (the managed JRE the app downloads also counts)
+//! - the bridge JAR for the current app version in `~/.sqlkit/jdbc-bridge/`
+//! - the DuckDB JDBC driver in `~/.sqlkit/jdbc-bridge/drivers/duckdb_jdbc/`
+//!
+//! Run with:
+//! `cargo test --test duckdb_bridge_integration -- --ignored --nocapture`
+
+use sqlkit_lib::database::{ConnectionConfig, DatabaseAdapter, DatabaseType, JdbcBridgeAdapter};
+use std::path::{Path, PathBuf};
+use std::time::{Duration, Instant};
+
+/// DuckDB file-based connection, mirroring what `ServerConfig` produces:
+/// the JDBC URL template takes the path (and URL options) from `database`.
+fn file_config(path: &Path, read_only: bool) -> ConnectionConfig {
+    let value = if read_only {
+        format!("{};access_mode=READ_ONLY", path.display())
+    } else {
+        path.to_string_lossy().to_string()
+    };
+    ConnectionConfig::new(DatabaseType::DuckDb, value.clone(), 0, "").with_database(value)
+}
+
+/// Named in-memory DuckDB instance — the value the connection form stores.
+fn memory_config(label: &str) -> ConnectionConfig {
+    let value = format!("memory:{}", label);
+    ConnectionConfig::new(DatabaseType::DuckDb, value.clone(), 0, "").with_database(value)
+}
+
+/// Second connection must reuse the bridge JVM: the first connection in a fresh
+/// process maps DuckDB's ~107 MB native library (~1.4 s measured), which would
+/// otherwise be paid again by every "Test connection" click.
+#[tokio::test]
+#[ignore]
+async fn second_connection_reuses_the_bridge_process() {
+    let mut first = JdbcBridgeAdapter::new(memory_config("sqlkit_integration_a"));
+    let started = Instant::now();
+    first.connect().await.expect("first connect");
+    let first_elapsed = started.elapsed();
+    first.disconnect().await.expect("first disconnect");
+
+    // Warm connects: the JVM, the driver's native library and the (once per
+    // session) Adoptium update check are already paid for.
+    let mut warm_total = Duration::ZERO;
+    const WARM_CONNECTS: u32 = 5;
+    for index in 0..WARM_CONNECTS {
+        let mut adapter = JdbcBridgeAdapter::new(memory_config(&format!("sqlkit_warm_{}", index)));
+        let started = Instant::now();
+        adapter.connect().await.expect("warm connect");
+        warm_total += started.elapsed();
+        adapter.disconnect().await.expect("warm disconnect");
+    }
+    let warm_average = warm_total / WARM_CONNECTS;
+
+    println!(
+        "cold connect: {:?}, warm average over {} connects: {:?}",
+        first_elapsed, WARM_CONNECTS, warm_average
+    );
+
+    // Before the bridge process was shared, every connect started a JVM and
+    // re-mapped DuckDB's native library: ~4.3 s each on this machine. With the
+    // shared process (and a bridge that caches driver class loaders) it is ~5 ms,
+    // so a 2.5 s average still catches a regression to the old behaviour.
+    assert!(
+        warm_average < Duration::from_millis(2500),
+        "warm connects should reuse the bridge process: cold={:?} warm average={:?}",
+        first_elapsed,
+        warm_average
+    );
+}
+
+/// Disconnecting must really close the pool inside the shared bridge: opening
+/// the same file read-only afterwards is rejected by DuckDB when a read-write
+/// instance is still alive ("same database file with a different configuration").
+///
+/// Read-only URLs also need a bridge build that sets HikariCP's read-only flag
+/// from the URL (`ConnectionManager.isReadOnlyUrl`); with an older bridge the
+/// driver rejects HikariCP's `setReadOnly(false)` call.
+#[tokio::test]
+#[ignore]
+async fn disconnect_closes_the_pool_and_releases_the_file() {
+    let dir = tempfile::tempdir().expect("temp dir");
+    let path: PathBuf = dir.path().join("shared.duckdb");
+
+    let mut writer = JdbcBridgeAdapter::new(file_config(&path, false));
+    writer.connect().await.expect("read-write connect");
+    writer
+        .execute_query("CREATE TABLE t AS SELECT 1 AS x")
+        .await
+        .expect("create table");
+    writer.disconnect().await.expect("read-write disconnect");
+
+    let mut reader = JdbcBridgeAdapter::new(file_config(&path, true));
+    if let Err(error) = reader.connect().await {
+        let message = error.to_string();
+        if message.contains("change read-only status") {
+            println!(
+                "SKIPPED: the installed bridge predates read-only URL support; \
+                 rebuild the bridge (jdbc-bridge/) to exercise this test. Error: {}",
+                message
+            );
+            return;
+        }
+        panic!(
+            "read-only connect after disconnect failed (the pool must be closed): {}",
+            message
+        );
+    }
+    let result = reader
+        .execute_query("SELECT count(*) AS n FROM t")
+        .await
+        .expect("read the table through the read-only connection");
+    assert_eq!(result.rows.len(), 1);
+    reader.disconnect().await.expect("read-only disconnect");
+
+    assert!(path.exists(), "the database file should exist");
+}
+
+/// Reconnecting read-write to the same file after a disconnect keeps working,
+/// which is what "Test connection" followed by "Save & Connect" does.
+#[tokio::test]
+#[ignore]
+async fn repeated_connect_and_disconnect_on_one_file() {
+    let dir = tempfile::tempdir().expect("temp dir");
+    let path = dir.path().join("reopen.duckdb");
+
+    for attempt in 1..=3 {
+        let mut adapter = JdbcBridgeAdapter::new(file_config(&path, false));
+        adapter
+            .connect()
+            .await
+            .unwrap_or_else(|e| panic!("connect #{} failed: {}", attempt, e));
+        adapter.disconnect().await.expect("disconnect");
+    }
+
+    let started = Instant::now();
+
+    let mut adapter = JdbcBridgeAdapter::new(file_config(&path, false));
+    adapter.connect().await.expect("final connect");
+    let status = adapter.test_connection().await.expect("test connection");
+    assert!(status.is_connected);
+    adapter.disconnect().await.expect("final disconnect");
+
+    println!("reconnect after three cycles: {:?}", started.elapsed());
+}
diff --git a/src/__tests__/databaseFiles.test.ts b/src/__tests__/databaseFiles.test.ts
new file mode 100644
index 00000000..af999aee
--- /dev/null
+++ b/src/__tests__/databaseFiles.test.ts
@@ -0,0 +1,226 @@
+import type { DatabaseFileProbe } from '@/utils/databaseFiles'
+import {
+  assessDatabaseFile,
+  buildMemoryDatabaseHost,
+  createMemoryDatabaseLabel,
+  formatFileSize,
+  isMemoryDatabaseHost,
+  isSameDatabaseFile,
+  memoryDatabaseLabel,
+  mergeRecentDatabase,
+  normalizeComparablePath,
+  recentDatabasesKey,
+  storageVersionMinRelease,
+  suggestDatabaseFileName,
+  withDatabaseExtension,
+} from '@/utils/databaseFiles'
+import { classifyDuckDbFailure } from '@/utils/duckdbErrors'
+
+function probe(overrides: Partial<DatabaseFileProbe> = {}): DatabaseFileProbe {
+  return {
+    path: '/tmp/app.duckdb',
+    exists: false,
+    isDirectory: false,
+    sizeBytes: null,
+    parentExists: true,
+    parentWritable: true,
+    writable: true,
+    format: null,
+    storageVersion: null,
+    hasWal: false,
+    ...overrides,
+  }
+}
+
+describe('database file paths', () => {
+  it('appends the engine extension only when the file name has none', () => {
+    expect(withDatabaseExtension('/tmp/analytics', 'duckdb')).toBe('/tmp/analytics.duckdb')
+    expect(withDatabaseExtension('/tmp/analytics.duckdb', 'duckdb')).toBe('/tmp/analytics.duckdb')
+    expect(withDatabaseExtension('/tmp/analytics.db', 'duckdb')).toBe('/tmp/analytics.db')
+    expect(withDatabaseExtension('/tmp/my.folder/analytics', 'duckdb')).toBe('/tmp/my.folder/analytics.duckdb')
+    expect(withDatabaseExtension('C:\\data\\analytics', 'duckdb')).toBe('C:\\data\\analytics.duckdb')
+    expect(withDatabaseExtension('   ', 'duckdb')).toBe('')
+  })
+
+  it('normalizes paths for duplicate detection', () => {
+    expect(normalizeComparablePath('/tmp/App.duckdb/', 'linux')).toBe('/tmp/App.duckdb')
+    expect(normalizeComparablePath('/tmp/App.duckdb', 'macos')).toBe('/tmp/app.duckdb')
+    expect(normalizeComparablePath('C:\\Data\\App.duckdb', 'windows')).toBe('c:\\data\\app.duckdb')
+  })
+
+  it('compares database files case-insensitively on macOS and Windows', () => {
+    expect(isSameDatabaseFile('/tmp/App.duckdb', '/tmp/app.duckdb', 'macos')).toBe(true)
+    expect(isSameDatabaseFile('/tmp/App.duckdb', '/tmp/app.duckdb', 'linux')).toBe(false)
+    expect(isSameDatabaseFile('', '/tmp/app.duckdb', 'linux')).toBe(false)
+  })
+
+  it('suggests a safe file name for the save dialog', () => {
+    expect(suggestDatabaseFileName('My Analytics')).toBe('My-Analytics.duckdb')
+    expect(suggestDatabaseFileName('sales/2026')).toBe('sales-2026.duckdb')
+    expect(suggestDatabaseFileName()).toBe('database.duckdb')
+  })
+})
+
+describe('duckdb memory instances', () => {
+  it('detects both sqlite and duckdb memory sentinels', () => {
+    expect(isMemoryDatabaseHost(':memory:')).toBe(true)
+    expect(isMemoryDatabaseHost('memory:sqlkit_ab12')).toBe(true)
+    expect(isMemoryDatabaseHost('/tmp/app.duckdb')).toBe(false)
+  })
+
+  it('round-trips a named in-memory instance', () => {
+    const label = createMemoryDatabaseLabel()
+    const host = buildMemoryDatabaseHost(label)
+    expect(host.startsWith('memory:sqlkit_')).toBe(true)
+    expect(memoryDatabaseLabel(host)).toBe(label)
+    expect(memoryDatabaseLabel('/tmp/app.duckdb')).toBe('')
+  })
+})
+
+describe('file probe assessment', () => {
+  it('treats memory hosts as memory without probing', () => {
+    expect(assessDatabaseFile(null, 'duckdb', 'memory:sqlkit_x').status).toBe('memory')
+    expect(assessDatabaseFile(null, 'duckdb', ':memory:').status).toBe('memory')
+  })
+
+  it('reports a missing path before a probe arrives', () => {
+    expect(assessDatabaseFile(null, 'duckdb', '').status).toBe('unknown')
+  })
+
+  it('explains that a missing file will be created by the engine', () => {
+    expect(assessDatabaseFile(probe(), 'duckdb', '/tmp/app.duckdb').status).toBe('will-create')
+  })
+
+  it('flags a missing parent directory and an unwritable parent', () => {
+    expect(assessDatabaseFile(probe({ parentExists: false }), 'duckdb', '/tmp/app.duckdb').status)
+      .toBe('missing-parent')
+    expect(assessDatabaseFile(probe({ parentWritable: false, writable: false }), 'duckdb', '/tmp/app.duckdb').status)
+      .toBe('unwritable')
+  })
+
+  it('flags directories and read-only files', () => {
+    expect(assessDatabaseFile(probe({ exists: true, isDirectory: true }), 'duckdb', '/tmp/app.duckdb').status)
+      .toBe('directory')
+    expect(assessDatabaseFile(probe({ exists: true, sizeBytes: 10, writable: false, format: 'duckdb' }), 'duckdb', '/tmp/app.duckdb').status)
+      .toBe('unwritable')
+  })
+
+  it('recognises empty and ready database files', () => {
+    expect(assessDatabaseFile(probe({ exists: true, sizeBytes: 0, format: 'unknown' }), 'duckdb', '/tmp/app.duckdb').status)
+      .toBe('empty')
+    expect(assessDatabaseFile(probe({ exists: true, sizeBytes: 8192, format: 'duckdb' }), 'duckdb', '/tmp/app.duckdb').status)
+      .toBe('ready')
+    expect(assessDatabaseFile(probe({ exists: true, sizeBytes: 8192, format: null }), 'duckdb', '/tmp/app.duckdb').status)
+      .toBe('ready')
+  })
+
+  it('rejects DuckDB paths the JDBC driver cannot parse', () => {
+    expect(assessDatabaseFile(null, 'duckdb', '/tmp/semi;colon.duckdb').status).toBe('unsupported-path')
+    // SQLite passes paths straight to the native engine, so ';' is fine there.
+    expect(assessDatabaseFile(probe({ exists: true, sizeBytes: 4096, format: 'sqlite' }), 'sqlite', '/tmp/semi;colon.db').status)
+      .toBe('ready')
+  })
+
+  it('flags files written by another engine', () => {
+    const assessment = assessDatabaseFile(
+      probe({ exists: true, sizeBytes: 4096, format: 'sqlite' }),
+      'duckdb',
+      '/tmp/legacy.db',
+    )
+    expect(assessment.status).toBe('wrong-format')
+    expect(assessment.format).toBe('sqlite')
+  })
+})
+
+describe('recent database files', () => {
+  it('keeps per-engine storage keys', () => {
+    expect(recentDatabasesKey('duckdb')).toBe('duckdb_recent_databases')
+    expect(recentDatabasesKey('sqlite')).toBe('sqlite_recent_databases')
+  })
+
+  it('moves a re-used path to the front and caps the list', () => {
+    const entries = [
+      { path: '/tmp/a.duckdb', timestamp: 2 },
+      { path: '/tmp/b.duckdb', timestamp: 1 },
+    ]
+    expect(mergeRecentDatabase(entries, '/tmp/b.duckdb', 3)).toEqual([
+      { path: '/tmp/b.duckdb', timestamp: 3 },
+      { path: '/tmp/a.duckdb', timestamp: 2 },
+    ])
+
+    const capped = mergeRecentDatabase(
+      Array.from({ length: 10 }, (_, index) => ({ path: `/tmp/${index}.duckdb`, timestamp: index })),
+      '/tmp/new.duckdb',
+      99,
+    )
+    expect(capped).toHaveLength(10)
+    expect(capped[0].path).toBe('/tmp/new.duckdb')
+  })
+
+  it('formats file sizes', () => {
+    expect(formatFileSize(0)).toBe('0 B')
+    expect(formatFileSize(512)).toBe('512 B')
+    expect(formatFileSize(2048)).toBe('2.0 KB')
+    expect(formatFileSize(15 * 1024 * 1024)).toBe('15 MB')
+    expect(formatFileSize(null)).toBe('')
+  })
+})
+
+describe('duckdb failure classification', () => {
+  it('recognises the file-lock failure and offers read-only', () => {
+    const hint = classifyDuckDbFailure('IO Error: Could not set lock on file "/tmp/app.duckdb": Conflicting lock is held')
+    expect(hint?.kind).toBe('lock-conflict')
+    expect(hint?.action).toBe('use-read-only')
+    expect(hint?.messageKey).toBe('components.serverForm.duckdbFailures.lock-conflict')
+  })
+
+  it('recognises the instance-configuration conflict', () => {
+    const hint = classifyDuckDbFailure('Connection Error: Can\'t open a connection to same database file with a different configuration than existing connections')
+    expect(hint?.kind).toBe('config-conflict')
+    expect(hint?.action).toBe('use-read-only')
+  })
+
+  it('explains read-only connections rejected by an older bridge', () => {
+    const hint = classifyDuckDbFailure('Failed to initialize pool: Can\'t change read-only status on connection level.')
+    expect(hint?.kind).toBe('read-only-unsupported')
+    expect(hint?.action).toBe('use-read-write')
+  })
+
+  it('recognises storage-format incompatibility', () => {
+    expect(classifyDuckDbFailure('Serialization Error: Failed to deserialize: ...')?.kind).toBe('storage-version')
+    expect(classifyDuckDbFailure('unable to open database: incompatible storage version')?.kind).toBe('storage-version')
+  })
+
+  it('recognises our own unsupported-path rejection', () => {
+    const ours = 'Invalid DuckDB database path: DuckDB\'s JDBC driver splits the connection URL on \';\', so a database path containing \';\' cannot be opened. Rename the file and try again.'
+    expect(classifyDuckDbFailure(ours)?.kind).toBe('unsupported-url')
+    // The driver's own wording, as surfaced by the JDBC bridge.
+    expect(classifyDuckDbFailure('Failed to verify connection: Invalid URL entry: colon.duckdb')?.kind)
+      .toBe('unsupported-url')
+  })
+
+  it('only applies generic signatures to DuckDB messages', () => {
+    expect(classifyDuckDbFailure('no such file or directory')?.kind).toBeUndefined()
+    expect(classifyDuckDbFailure('DuckDB: IO Error: No such file or directory')?.kind).toBe('missing-file')
+    expect(classifyDuckDbFailure('duckdb: IO Error: No such file or directory')?.kind).toBe('missing-file')
+    // A PostgreSQL error must not be explained with DuckDB advice.
+    expect(classifyDuckDbFailure('database "reports" does not exist')).toBeNull()
+  })
+
+  it('returns null for unrelated errors', () => {
+    expect(classifyDuckDbFailure('password authentication failed for user "postgres"')).toBeNull()
+    expect(classifyDuckDbFailure('')).toBeNull()
+    expect(classifyDuckDbFailure(null)).toBeNull()
+  })
+})
+
+describe('storage versions', () => {
+  it('maps DuckDB storage versions to the oldest compatible release', () => {
+    // 64 is what duckdb_jdbc 1.5.6 writes; DuckDB itself reports v1.0.0+.
+    expect(storageVersionMinRelease(64)).toBe('v1.0.0')
+    expect(storageVersionMinRelease(65)).toBe('v1.2.0')
+    expect(storageVersionMinRelease(66)).toBe('v1.3.0')
+    expect(storageVersionMinRelease(99)).toBeNull()
+    expect(storageVersionMinRelease(null)).toBeNull()
+  })
+})
diff --git a/src/__tests__/i18nKeys.test.ts b/src/__tests__/i18nKeys.test.ts
new file mode 100644
index 00000000..4909b9e3
--- /dev/null
+++ b/src/__tests__/i18nKeys.test.ts
@@ -0,0 +1,82 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import { enUS } from '@/lang/enUS'
+import { zhCN } from '@/lang/zhCN'
+
+/**
+ * Guards against the class of bug where a literal `t('some.key')` does not
+ * resolve and the raw key ends up rendered in the UI (e.g. a menu item showing
+ * `pages.connections.newMenu.duckdbFile`).
+ *
+ * Only literal single-quoted keys are inspected; computed/template keys are
+ * intentionally skipped because they cannot be resolved statically.
+ */
+
+const SRC_ROOT = path.resolve(__dirname, '..')
+const SKIPPED_DIRECTORIES = new Set(['lang', 'node_modules'])
+const KEY_PATTERN = /\$?\bt\(\s*'([\w.-]+)'/g
+
+function collectSourceFiles(dir: string): string[] {
+  return fs.readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+    const fullPath = path.join(dir, entry.name)
+    if (entry.isDirectory())
+      return SKIPPED_DIRECTORIES.has(entry.name) ? [] : collectSourceFiles(fullPath)
+    // This guard file mentions key patterns in its own documentation.
+    if (entry.name === 'i18nKeys.test.ts')
+      return []
+    return /\.(?:vue|ts)$/.test(entry.name) ? [fullPath] : []
+  })
+}
+
+/** Key patterns inside comments are documentation, not usage. */
+function stripComments(source: string): string {
+  return source.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(?<!:)\/\/.*$/gm, '')
+}
+
+function lookup(messages: Record<string, unknown>, key: string): unknown {
+  return key
+    .split('.')
+    .reduce<unknown>(
+      (acc, part) => (acc && typeof acc === 'object' ? (acc as Record<string, unknown>)[part] : undefined),
+      messages,
+    )
+}
+
+function collectLiteralKeys(files: string[]): Map<string, string> {
+  const keys = new Map<string, string>()
+  for (const file of files) {
+    const content = stripComments(fs.readFileSync(file, 'utf8'))
+    for (const match of content.matchAll(KEY_PATTERN)) {
+      const key = match[1]
+      if (key.includes('.') && !keys.has(key))
+        keys.set(key, path.relative(SRC_ROOT, file))
+    }
+  }
+  return keys
+}
+
+describe('i18n message keys', () => {
+  const files = collectSourceFiles(SRC_ROOT)
+  const keys = collectLiteralKeys(files)
+
+  it('finds the translation keys used in source files', () => {
+    expect(files.length).toBeGreaterThan(100)
+    expect(keys.size).toBeGreaterThan(100)
+  })
+
+  it('resolves every literal key in enUS', () => {
+    const missing = [...keys.entries()]
+      .filter(([key]) => lookup(enUS as unknown as Record<string, unknown>, key) === undefined)
+      .map(([key, file]) => `${key} (${file})`)
+
+    expect(missing).toEqual([])
+  })
+
+  it('resolves every literal key in zhCN', () => {
+    const missing = [...keys.entries()]
+      .filter(([key]) => lookup(zhCN as unknown as Record<string, unknown>, key) === undefined)
+      .map(([key, file]) => `${key} (${file})`)
+
+    expect(missing).toEqual([])
+  })
+})
diff --git a/src/components/DeviceReplaceDialog.vue b/src/components/DeviceReplaceDialog.vue
index f1af8f59..dbbc822e 100644
--- a/src/components/DeviceReplaceDialog.vue
+++ b/src/components/DeviceReplaceDialog.vue
@@ -135,7 +135,7 @@ function handleOpenChange(open: boolean) {
 
       <div class="dialog-actions">
         <Button variant="outline" @click="deviceStore.dismissReplaceDialog()">
-          {{ $t('common.cancel') }}
+          {{ $t('common.buttons.cancel') }}
         </Button>
         <Button :disabled="!selectedDeviceId || deviceStore.activating" @click="handleReplace">
           <Spinner v-if="deviceStore.activating" class="mr-2 h-4 w-4" />
diff --git a/src/components/connections/ConnectingModal.vue b/src/components/connections/ConnectingModal.vue
index 72fabe77..2ccebe8b 100644
--- a/src/components/connections/ConnectingModal.vue
+++ b/src/components/connections/ConnectingModal.vue
@@ -1,9 +1,10 @@
 <script setup lang="ts">
-import { ref } from 'vue'
+import { computed, ref } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { Button } from '@/components/ui/button'
 import { Dialog, DialogContent, DialogTitle } from '@/components/ui/dialog'
 import { Spinner } from '@/components/ui/spinner'
+import { classifyDuckDbFailure } from '@/utils/duckdbErrors'
 
 const { t } = useI18n()
 
@@ -12,6 +13,7 @@ const connectionName = ref('')
 const errorMessage = ref('')
 const cancelCallback = ref<(() => void) | null>(null)
 const retryCallback = ref<(() => void) | null>(null)
+const failureHint = computed(() => classifyDuckDbFailure(errorMessage.value))
 
 function show(name: string, onCancel: () => void, onRetry: () => void) {
   connectionName.value = name
@@ -99,6 +101,9 @@ defineExpose({
               <p class="mt-1 opacity-90">
                 {{ errorMessage }}
               </p>
+              <p v-if="failureHint" class="text-xs mt-2 opacity-90">
+                {{ t(failureHint.messageKey) }}
+              </p>
             </div>
             <button
               class="opacity-70 transition-opacity hover:opacity-100"
diff --git a/src/components/connections/DatabaseFileField.vue b/src/components/connections/DatabaseFileField.vue
new file mode 100644
index 00000000..f1cd4805
--- /dev/null
+++ b/src/components/connections/DatabaseFileField.vue
@@ -0,0 +1,342 @@
+<script setup lang="ts">
+import type { DatabaseFileAssessment, DatabaseFileFormat, DatabaseFileProbe, RecentDatabaseEntry } from '@/utils/databaseFiles'
+import { invoke } from '@tauri-apps/api/core'
+import { open as openDialog, save as saveDialog } from '@tauri-apps/plugin-dialog'
+import { revealItemInDir } from '@tauri-apps/plugin-opener'
+import { computed, onMounted, ref, watch } from 'vue'
+import { useI18n } from 'vue-i18n'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Label } from '@/components/ui/label'
+import { toast } from '@/composables/useNotifications'
+import {
+  assessDatabaseFile,
+  DUCKDB_EXTENSIONS,
+  formatFileSize,
+  mergeRecentDatabase,
+  recentDatabasesKey,
+  SQLITE_EXTENSIONS,
+  storageVersionMinRelease,
+  suggestDatabaseFileName,
+  withDatabaseExtension,
+} from '@/utils/databaseFiles'
+
+const props = defineProps<{
+  modelValue: string
+  engine: 'sqlite' | 'duckdb'
+  label: string
+  placeholder: string
+  errorMessage?: string
+  required?: boolean
+  /** Base name offered to the save dialog when creating a new file. */
+  suggestedName?: string
+}>()
+
+const emit = defineEmits<{
+  (e: 'update:modelValue', value: string): void
+  (e: 'status', value: DatabaseFileAssessment): void
+  (e: 'picking', value: boolean): void
+}>()
+
+const { t } = useI18n()
+
+const isPicking = ref(false)
+const probeResult = ref<DatabaseFileProbe | null>(null)
+const recentDatabases = ref<RecentDatabaseEntry[]>([])
+
+const pathModel = computed({
+  get: () => props.modelValue,
+  set: value => emit('update:modelValue', value),
+})
+
+const expectedFormat = computed<DatabaseFileFormat>(() => (props.engine === 'duckdb' ? 'duckdb' : 'sqlite'))
+
+const filters = computed(() => props.engine === 'duckdb'
+  ? [
+      { name: 'DuckDB', extensions: DUCKDB_EXTENSIONS },
+      { name: 'All Files', extensions: ['*'] },
+    ]
+  : [
+      { name: 'Database', extensions: SQLITE_EXTENSIONS },
+      { name: 'All Files', extensions: ['*'] },
+    ])
+
+const storageKey = computed(() => recentDatabasesKey(props.engine))
+
+const assessment = computed(() => assessDatabaseFile(probeResult.value, expectedFormat.value, props.modelValue))
+
+function loadRecentDatabases() {
+  try {
+    const stored = localStorage.getItem(storageKey.value)
+    recentDatabases.value = stored ? JSON.parse(stored) : []
+  }
+  catch {
+    recentDatabases.value = []
+  }
+}
+
+function persistRecentDatabases(entries: RecentDatabaseEntry[]) {
+  recentDatabases.value = entries
+  localStorage.setItem(storageKey.value, JSON.stringify(entries))
+}
+
+function rememberDatabase(path: string) {
+  return persistRecentDatabases(mergeRecentDatabase(recentDatabases.value, path, Date.now()))
+}
+
+function removeRecentDatabase(path: string) {
+  return persistRecentDatabases(recentDatabases.value.filter(entry => entry.path !== path))
+}
+
+async function runProbe(path: string) {
+  const trimmed = (path ?? '').trim()
+  if (!trimmed || trimmed.startsWith('memory:') || trimmed === ':memory:') {
+    probeResult.value = null
+    return
+  }
+  try {
+    probeResult.value = await invoke<DatabaseFileProbe>('probe_database_file', { path: trimmed })
+  }
+  catch {
+    probeResult.value = null
+  }
+}
+
+let probeTimer: ReturnType<typeof setTimeout> | undefined
+
+watch(() => props.modelValue, (value) => {
+  if (probeTimer)
+    clearTimeout(probeTimer)
+  probeTimer = setTimeout(() => runProbe(value ?? ''), 250)
+})
+
+watch(assessment, value => emit('status', value), { immediate: true })
+
+onMounted(() => {
+  loadRecentDatabases()
+  runProbe(props.modelValue ?? '')
+})
+
+function selectPath(path: string) {
+  pathModel.value = path
+}
+
+function applyPicked(path: string) {
+  const normalized = props.engine === 'duckdb' ? withDatabaseExtension(path, 'duckdb') : path
+  selectPath(normalized)
+  rememberDatabase(normalized)
+  runProbe(normalized)
+}
+
+async function createDatabaseFile() {
+  isPicking.value = true
+  emit('picking', true)
+  try {
+    const selected = await saveDialog({
+      defaultPath: props.suggestedName || suggestDatabaseFileName(),
+      filters: filters.value,
+    })
+    if (typeof selected === 'string' && selected)
+      applyPicked(selected)
+  }
+  catch (error) {
+    toast.error(t('components.serverForm.errors.filePickerFailed'), {
+      description: error instanceof Error ? error.message : String(error),
+    })
+  }
+  finally {
+    isPicking.value = false
+    emit('picking', false)
+  }
+}
+
+async function openDatabaseFile() {
+  isPicking.value = true
+  emit('picking', true)
+  try {
+    const selected = await openDialog({ multiple: false, filters: filters.value })
+    if (typeof selected === 'string' && selected)
+      applyPicked(selected)
+  }
+  catch (error) {
+    toast.error(t('components.serverForm.errors.filePickerFailed'), {
+      description: error instanceof Error ? error.message : String(error),
+    })
+  }
+  finally {
+    isPicking.value = false
+    emit('picking', false)
+  }
+}
+
+async function createParentDirectory() {
+  try {
+    probeResult.value = await invoke<DatabaseFileProbe>('create_database_directory', {
+      path: props.modelValue.trim(),
+    })
+  }
+  catch (error) {
+    toast.error(t('components.serverForm.fileStatus.createDirectoryFailed'), {
+      description: error instanceof Error ? error.message : String(error),
+    })
+  }
+}
+
+async function revealDatabaseFile(path: string) {
+  try {
+    await revealItemInDir(path)
+  }
+  catch (error) {
+    toast.error(t('components.serverForm.fileStatus.revealFailed'), {
+      description: error instanceof Error ? error.message : String(error),
+    })
+  }
+}
+
+type StatusDescriptor = {
+  tone: 'info' | 'success' | 'warning' | 'error'
+  message: string
+  action?: 'create-directory'
+}
+
+const status = computed<StatusDescriptor | null>(() => {
+  const value = assessment.value
+  const engineName = props.engine === 'duckdb' ? 'DuckDB' : 'SQLite'
+  const formatName = value.format === 'sqlite' ? 'SQLite' : t('components.serverForm.fileStatus.unknownFormat')
+
+  const descriptors: Record<Exclude<DatabaseFileAssessment['status'], 'memory'>, StatusDescriptor> = {
+    'unknown': { tone: 'info', message: '' },
+    'will-create': { tone: 'info', message: t('components.serverForm.fileStatus.willCreate', { engine: engineName }) },
+    'missing-parent': {
+      tone: 'warning',
+      message: t('components.serverForm.fileStatus.missingParent'),
+      action: 'create-directory',
+    },
+    'unwritable': { tone: 'warning', message: t('components.serverForm.fileStatus.unwritable') },
+    'directory': { tone: 'error', message: t('components.serverForm.fileStatus.directory') },
+    'empty': { tone: 'info', message: t('components.serverForm.fileStatus.empty') },
+    'ready': { tone: 'success', message: t('components.serverForm.fileStatus.ready', { size: formatFileSize(value.sizeBytes) }) },
+    'unsupported-path': { tone: 'error', message: t('components.serverForm.fileStatus.unsupportedPath') },
+    'wrong-format': {
+      tone: 'warning',
+      message: t('components.serverForm.fileStatus.wrongFormat', { format: formatName, engine: engineName }),
+    },
+  }
+
+  if (value.status === 'memory')
+    return null
+
+  const descriptor = descriptors[value.status]
+  return descriptor.message ? descriptor : null
+})
+
+const fileDetails = computed(() => {
+  const value = probeResult.value
+  const details: string[] = []
+  if (!value)
+    return details
+
+  const storageVersion = value.storageVersion
+  if (storageVersion !== null && storageVersion !== undefined) {
+    const minRelease = storageVersionMinRelease(storageVersion)
+    details.push(minRelease
+      ? t('components.serverForm.fileStatus.storageVersion', { version: minRelease, storage: storageVersion })
+      : t('components.serverForm.fileStatus.storageVersionUnknown', { storage: storageVersion }))
+  }
+  if (value.hasWal)
+    details.push(t('components.serverForm.fileStatus.writeAheadLog'))
+
+  return details
+})
+
+const toneClass: Record<StatusDescriptor['tone'], string> = {
+  info: 'text-muted-foreground',
+  success: 'text-muted-foreground',
+  warning: 'text-amber-600 dark:text-amber-500',
+  error: 'text-destructive',
+}
+
+const toneIcon: Record<StatusDescriptor['tone'], string> = {
+  info: 'i-carbon-information',
+  success: 'i-carbon-checkmark',
+  warning: 'i-carbon-warning',
+  error: 'i-carbon-warning-alt',
+}
+</script>
+
+<template>
+  <div class="space-y-2">
+    <Label :for="`db-file-${engine}`">
+      {{ label }}<span v-if="required" class="text-destructive ml-0.5">*</span>
+    </Label>
+    <div class="flex gap-2 items-center">
+      <Input
+        :id="`db-file-${engine}`"
+        v-model="pathModel"
+        :placeholder="placeholder"
+        :class="{ 'border-destructive': errorMessage }"
+        class="flex-1"
+      />
+      <Button type="button" variant="outline" size="sm" :disabled="isPicking" @click="createDatabaseFile">
+        {{ t('components.serverForm.buttons.create') }}
+      </Button>
+      <Button type="button" variant="outline" size="sm" :disabled="isPicking" @click="openDatabaseFile">
+        {{ t('components.serverForm.buttons.open') }}
+      </Button>
+    </div>
+
+    <p v-if="errorMessage" class="text-sm text-destructive">
+      {{ errorMessage }}
+    </p>
+
+    <div v-if="status" class="text-xs flex gap-2 items-center" :class="toneClass[status.tone]">
+      <span class="shrink-0 h-3.5 w-3.5" :class="toneIcon[status.tone]" />
+      <span class="flex-1">{{ status.message }}</span>
+      <Button
+        v-if="status.action === 'create-directory'"
+        type="button"
+        variant="ghost"
+        size="sm"
+        class="text-xs px-2 h-6"
+        @click="createParentDirectory"
+      >
+        {{ t('components.serverForm.fileStatus.createDirectory') }}
+      </Button>
+    </div>
+
+    <div v-if="fileDetails.length > 0" class="text-xs text-muted-foreground flex flex-wrap gap-x-3 gap-y-1">
+      <span v-for="detail in fileDetails" :key="detail">{{ detail }}</span>
+    </div>
+
+    <div v-if="recentDatabases.length > 0" class="space-y-1">
+      <Label class="text-xs text-muted-foreground">{{ t('components.serverForm.labels.recentDatabases') }}</Label>
+      <div class="p-1 border rounded-md max-h-32 overflow-y-auto space-y-0.5">
+        <div
+          v-for="entry in recentDatabases"
+          :key="entry.path"
+          class="group text-sm p-1 rounded flex gap-2 cursor-pointer items-center hover:bg-muted"
+          @click="selectPath(entry.path)"
+        >
+          <span class="i-carbon-document text-muted-foreground shrink-0 h-4 w-4" />
+          <span class="flex-1 truncate" :title="entry.path">{{ entry.path }}</span>
+          <button
+            type="button"
+            class="text-muted-foreground opacity-0 shrink-0 hover:text-foreground group-hover:opacity-100"
+            :title="t('components.serverForm.fileStatus.reveal')"
+            @click.stop="revealDatabaseFile(entry.path)"
+          >
+            <span class="i-carbon-launch h-4 w-4 block" />
+          </button>
+          <button
+            type="button"
+            class="text-muted-foreground opacity-0 shrink-0 hover:text-destructive group-hover:opacity-100"
+            :title="t('components.serverForm.fileStatus.removeRecent')"
+            @click.stop="removeRecentDatabase(entry.path)"
+          >
+            <span class="i-carbon-close h-4 w-4 block" />
+          </button>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/src/components/connections/ServerFormDialog.vue b/src/components/connections/ServerFormDialog.vue
index c67a622f..ba3fe8c7 100644
--- a/src/components/connections/ServerFormDialog.vue
+++ b/src/components/connections/ServerFormDialog.vue
@@ -1,5 +1,6 @@
 <script setup lang="ts">
 import type { OracleConnectionOptions, ServerConnection } from '@/store'
+import type { DatabaseFileAssessment } from '@/utils/databaseFiles'
 import { invoke } from '@tauri-apps/api/core'
 import { open as openDialog } from '@tauri-apps/plugin-dialog'
 import { computed, ref, watch } from 'vue'
@@ -22,10 +23,14 @@ import { openUpgradeDialog } from '@/components/upgrade'
 import { useDatabaseIcon } from '@/composables/useDatabaseIcon'
 import { useDownloadEvents } from '@/composables/useDownloadEvents'
 import { toast } from '@/composables/useNotifications'
+import { usePlatform } from '@/composables/usePlatform'
 import { jdbcApi } from '@/datasources/jdbcApi'
-import { buildOracleOptions, buildTransportLayers, databasePlaceholderFor, DatabaseType, dbTypeToBackend, isDatabaseRequired, isJdbcDatabase, resolveDatabase } from '@/store'
+import { buildOracleOptions, buildTransportLayers, databasePlaceholderFor, DatabaseType, dbTypeToBackend, isDatabaseRequired, isJdbcDatabase, resolveDatabase, useConnectionStore } from '@/store'
 import { useEntitlementStore } from '@/store/entitlementStore'
 import { DEFAULT_SSL_MODE, sslModeToBackend, validateSslConfig } from '@/types/connection'
+import { buildMemoryDatabaseHost, createMemoryDatabaseLabel, isMemoryDatabaseHost, isSameDatabaseFile, memoryDatabaseLabel } from '@/utils/databaseFiles'
+import { classifyDuckDbFailure } from '@/utils/duckdbErrors'
+import DatabaseFileField from './DatabaseFileField.vue'
 import SslConfigSection from './ssl/SslConfigSection.vue'
 
 const props = defineProps<{
@@ -205,44 +210,20 @@ function toggleSsh(checked: boolean) {
 
 // SQLite-specific state
 const sqliteTab = ref<'file' | 'in-memory'>('file')
-const recentDatabases = ref<Array<{ path: string, timestamp: number }>>([])
 const savedFilePath = ref<string>('') // Preserve file path when switching to in-memory
 
-// Load recent databases from localStorage
-const RECENT_DB_KEY = 'sqlite_recent_databases'
-const MAX_RECENT_DB = 10
+// DuckDB-specific state. DuckDB mirrors the SQLite File / In-Memory split, but
+// in-memory databases are *named* instances (`memory:<label>`): the JDBC pool
+// opens several connections, and unnamed in-memory databases are private to a
+// single connection, so every pooled connection would otherwise see its own
+// empty database.
+const duckdbTab = ref<'file' | 'in-memory'>('file')
+const savedDuckDbFilePath = ref<string>('')
+const duckdbMemoryLabel = ref<string>('')
+const duckdbFileStatus = ref<DatabaseFileAssessment | null>(null)
 
-function loadRecentDatabases() {
-  try {
-    const stored = localStorage.getItem(RECENT_DB_KEY)
-    if (stored)
-      recentDatabases.value = JSON.parse(stored)
-  }
-  catch {
-    recentDatabases.value = []
-  }
-}
-
-function saveRecentDatabase(path: string) {
-  const updated = [{ path, timestamp: Date.now() }, ...recentDatabases.value.filter(db => db.path !== path)].slice(0, MAX_RECENT_DB)
-  recentDatabases.value = updated
-  localStorage.setItem(RECENT_DB_KEY, JSON.stringify(updated))
-}
-
-function formatTimeAgo(timestamp: number): string {
-  const seconds = Math.floor((Date.now() - timestamp) / 1000)
-  const minutes = Math.floor(seconds / 60)
-  const hours = Math.floor(minutes / 60)
-  const days = Math.floor(hours / 24)
-
-  if (days > 0)
-    return t('components.serverForm.sqlite.ago', { time: `${days}d` })
-  if (hours > 0)
-    return t('components.serverForm.sqlite.ago', { time: `${hours}h` })
-  if (minutes > 0)
-    return t('components.serverForm.sqlite.ago', { time: `${minutes}m` })
-  return t('components.serverForm.sqlite.ago', { time: `${seconds}s` })
-}
+const connectionStore = useConnectionStore()
+const { platform } = usePlatform()
 
 watch(() => props.open, (open) => {
   if (open) {
@@ -258,6 +239,17 @@ watch(() => props.open, (open) => {
           savedFilePath.value = props.connection.host
         }
       }
+      // Detect DuckDB File / In-Memory mode from the stored host
+      if (props.connection.type === DatabaseType.DUCKDB) {
+        if (isMemoryDatabaseHost(props.connection.host)) {
+          duckdbTab.value = 'in-memory'
+          duckdbMemoryLabel.value = memoryDatabaseLabel(props.connection.host) || createMemoryDatabaseLabel()
+        }
+        else {
+          duckdbTab.value = 'file'
+          savedDuckDbFilePath.value = props.connection.host
+        }
+      }
       // Sync Oracle options when editing
       if (props.connection.type === DatabaseType.ORACLE) {
         syncOracleFromFormData()
@@ -271,6 +263,10 @@ watch(() => props.open, (open) => {
       formData.value = { ...defaultConnection }
       sqliteTab.value = 'file'
       savedFilePath.value = ''
+      duckdbTab.value = 'file'
+      savedDuckDbFilePath.value = ''
+      duckdbMemoryLabel.value = ''
+      duckdbFileStatus.value = null
       resetOracleOptions()
     }
     testStatus.value = 'idle'
@@ -281,7 +277,6 @@ watch(() => props.open, (open) => {
       s.progress = undefined
       s.error = undefined
     })
-    loadRecentDatabases()
   }
 })
 
@@ -302,6 +297,25 @@ watch(sqliteTab, (tab) => {
   }
 })
 
+// Watch for DuckDB tab changes: in-memory mode stores a named instance host
+watch(duckdbTab, (tab) => {
+  if (formData.value.type !== DatabaseType.DUCKDB)
+    return
+
+  if (tab === 'in-memory') {
+    if (!isMemoryDatabaseHost(formData.value.host))
+      savedDuckDbFilePath.value = formData.value.host
+    if (!duckdbMemoryLabel.value)
+      duckdbMemoryLabel.value = createMemoryDatabaseLabel()
+    formData.value.host = buildMemoryDatabaseHost(duckdbMemoryLabel.value)
+    formData.value.readOnly = false
+    duckdbFileStatus.value = null
+  }
+  else {
+    formData.value.host = savedDuckDbFilePath.value
+  }
+})
+
 function handleDatabaseTypeChange(value: string) {
   // Validate that value is a valid DatabaseType
   if (!Object.values(DatabaseType).includes(value as DatabaseType)) {
@@ -329,9 +343,19 @@ function handleDatabaseTypeChange(value: string) {
       formData.value.username = ''
       formData.value.password = ''
     }
-    sqliteTab.value = type === DatabaseType.SQLITE ? 'file' : 'file'
+    sqliteTab.value = 'file'
     savedFilePath.value = ''
   }
+  if (type === DatabaseType.DUCKDB) {
+    duckdbTab.value = 'file'
+    savedDuckDbFilePath.value = ''
+    duckdbMemoryLabel.value = ''
+    duckdbFileStatus.value = null
+    formData.value.readOnly = false
+  }
+  if (type !== DatabaseType.DUCKDB && type !== DatabaseType.SQLITE) {
+    formData.value.readOnly = false
+  }
 }
 
 const isFileBased = computed(() =>
@@ -347,6 +371,67 @@ const isEncryptedFileDb = computed(() =>
 
 const isJdbcDb = computed(() => isJdbcDatabase(formData.value.type))
 
+const isDuckDb = computed(() => formData.value.type === DatabaseType.DUCKDB)
+
+const isDuckDbFileMode = computed(() =>
+  isDuckDb.value
+  && duckdbTab.value === 'file'
+  && !isMemoryDatabaseHost(formData.value.host),
+)
+
+// DuckDB caches one database instance per file inside the JDBC process, and
+// options are instance-scoped: a second connection to the same file with a
+// different configuration (read-only vs read-write) is rejected by the driver.
+// Block that combination up front instead of surfacing the raw engine error.
+const duckDbFileConnections = computed(() => {
+  if (!isDuckDbFileMode.value || !formData.value.host.trim())
+    return []
+  return connectionStore.connections.filter(connection =>
+    connection.id !== formData.value.id
+    && connection.type === DatabaseType.DUCKDB
+    && !isMemoryDatabaseHost(connection.host)
+    && isSameDatabaseFile(connection.host, formData.value.host, platform.value ?? 'unknown'),
+  )
+})
+
+const conflictingDuckDbConnection = computed(() =>
+  duckDbFileConnections.value.find(connection =>
+    (connection.readOnly ?? false) !== (formData.value.readOnly ?? false),
+  ),
+)
+
+const sharedDuckDbConnection = computed(() =>
+  duckDbFileConnections.value.find(connection =>
+    (connection.readOnly ?? false) === (formData.value.readOnly ?? false),
+  ),
+)
+
+function handleDuckDbFileStatus(status: DatabaseFileAssessment) {
+  duckdbFileStatus.value = status
+}
+
+const testFailureHint = computed(() =>
+  isDuckDb.value ? classifyDuckDbFailure(testError.value) : null,
+)
+
+async function retryAsReadOnly() {
+  formData.value.readOnly = true
+  testStatus.value = 'idle'
+  await handleTestConnection()
+}
+
+async function retryAsReadWrite() {
+  formData.value.readOnly = false
+  testStatus.value = 'idle'
+  await handleTestConnection()
+}
+
+function switchToConnection(connection: ServerConnection) {
+  if (connection.id)
+    connectionStore.setActiveConnection(connection.id)
+  isOpen.value = false
+}
+
 const dbTypeI18nKeyMap: Record<string, string> = {
   MANTICORESEARCH: 'manticore',
 }
@@ -516,37 +601,6 @@ async function browseDirectory(target: 'tns' | 'wallet') {
   }
 }
 
-// SQLite file picker function - handles both open existing and create new
-async function selectDatabaseFile() {
-  isPickingFile.value = true
-  try {
-    const selected = await openDialog({
-      multiple: false,
-      filters: [
-        { name: 'Database', extensions: ['db', 'sqlite', 'sqlite3', 'sqlcipher', 'db3'] },
-        { name: 'DuckDB', extensions: ['duckdb', 'db'] },
-        { name: 'All Files', extensions: ['*'] },
-      ],
-    })
-    if (typeof selected === 'string') {
-      formData.value.host = selected
-    }
-  }
-  catch (error) {
-    toast.error(t('components.serverForm.errors.filePickerFailed'), {
-      description: error instanceof Error ? error.message : String(error),
-    })
-  }
-  finally {
-    isPickingFile.value = false
-  }
-}
-
-// Handle recent database selection
-function selectRecentDatabase(path: string) {
-  formData.value.host = path
-}
-
 function validateForm(): boolean {
   const errors: Record<string, string> = {}
 
@@ -555,9 +609,20 @@ function validateForm(): boolean {
   }
 
   if (isFileBased.value) {
-    if (formData.value.host !== ':memory:' && !formData.value.host.trim()) {
+    if (!isMemoryDatabaseHost(formData.value.host) && !formData.value.host.trim()) {
       errors.host = t('components.serverForm.errors.filePathRequired')
     }
+    else if (conflictingDuckDbConnection.value) {
+      errors.host = t('components.serverForm.duckdb.conflictingConnection', {
+        name: conflictingDuckDbConnection.value.name,
+      })
+    }
+    else if (isDuckDbFileMode.value && duckdbFileStatus.value?.status === 'directory') {
+      errors.host = t('components.serverForm.fileStatus.directory')
+    }
+    else if (isDuckDbFileMode.value && duckdbFileStatus.value?.status === 'unsupported-path') {
+      errors.host = t('components.serverForm.fileStatus.unsupportedPath')
+    }
   }
   else if (isOracle.value && !showsStandardHostFields.value) {
     // Oracle TNS / Cloud Wallet: TNS admin dir and alias required
@@ -680,6 +745,7 @@ async function handleTestConnection() {
       trust_server_certificate: formData.value.ssl.trustServerCertificate ?? null,
       transport_layers: buildTransportLayers(formData.value.sshTunnel),
       oracle_options: buildOracleOptions(formData.value.oracleOptions),
+      read_only: formData.value.readOnly ?? false,
     }
 
     // Small yield to let Vue render the loading state before the blocking invoke
@@ -778,14 +844,6 @@ function handleSave() {
     return
   }
 
-  // Save recent database path for file-based databases
-  if (
-    (formData.value.type === DatabaseType.SQLITE || formData.value.type === DatabaseType.SQLCIPHER)
-    && formData.value.host !== ':memory:'
-  ) {
-    saveRecentDatabase(formData.value.host)
-  }
-
   emit('save', { ...formData.value })
   isOpen.value = false
 }
@@ -1121,7 +1179,7 @@ function handleSave() {
           </div>
         </div>
 
-        <!-- SQLite/SQLCipher-specific fields -->
+        <!-- SQLite/SQLCipher/DuckDB-specific fields -->
         <div v-if="isFileBased" class="space-y-4">
           <!-- SQLite with file/in-memory tabs -->
           <template v-if="formData.type === DatabaseType.SQLITE">
@@ -1137,53 +1195,15 @@ function handleSave() {
 
               <!-- File Mode -->
               <TabsContent value="file" class="space-y-4">
-                <!-- Database File Path -->
-                <div class="space-y-2">
-                  <Label for="sqlite-path">{{ t('components.serverForm.labels.databaseFilePath') }}<span class="text-destructive ml-0.5">*</span></Label>
-                  <div class="flex gap-2 items-center">
-                    <Input
-                      id="sqlite-path"
-                      v-model="formData.host"
-                      :placeholder="t('components.serverForm.placeholders.filePath')"
-                      :class="{ 'border-destructive': formErrors.host }"
-                      readonly
-                      class="flex-1"
-                    />
-                    <Button
-                      type="button"
-                      variant="outline"
-                      size="sm"
-                      @click="selectDatabaseFile"
-                    >
-                      {{ t('common.buttons.browse') }}
-                    </Button>
-                  </div>
-                  <p v-if="formErrors.host" class="text-sm text-destructive">
-                    {{ formErrors.host }}
-                  </p>
-                </div>
-
-                <!-- Recent Databases -->
-                <div v-if="recentDatabases.length > 0" class="space-y-2">
-                  <Label>{{ t('components.serverForm.labels.recentDatabases') }}</Label>
-                  <div class="p-2 border rounded-md max-h-32 overflow-y-auto space-y-1">
-                    <div
-                      v-for="db in recentDatabases"
-                      :key="db.path"
-                      class="text-sm p-1 rounded flex gap-2 cursor-pointer items-center hover:bg-muted"
-                      @click="selectRecentDatabase(db.path)"
-                    >
-                      <span class="i-carbon-document text-muted-foreground h-4 w-4" />
-                      <span class="flex-1 truncate">{{ db.path }}</span>
-                      <span class="text-xs text-muted-foreground">{{ formatTimeAgo(db.timestamp) }}</span>
-                    </div>
-                  </div>
-                </div>
-
-                <!-- Empty state for recent databases -->
-                <div v-if="recentDatabases.length === 0" class="text-sm text-muted-foreground">
-                  {{ t('components.serverForm.sqlite.recentEmpty') }}
-                </div>
+                <DatabaseFileField
+                  v-model="formData.host"
+                  engine="sqlite"
+                  required
+                  :label="t('components.serverForm.labels.databaseFilePath')"
+                  :placeholder="t('components.serverForm.placeholders.filePath')"
+                  :error-message="formErrors.host"
+                  @picking="isPickingFile = $event"
+                />
               </TabsContent>
 
               <!-- In-Memory Mode -->
@@ -1197,77 +1217,147 @@ function handleSave() {
 
           <!-- SQLCipher: file picker + encryption key -->
           <template v-else-if="formData.type === DatabaseType.SQLCIPHER">
-            <div class="space-y-2">
-              <Label for="sqlcipher-path">{{ t('components.serverForm.labels.databaseFilePath') }}<span class="text-destructive ml-0.5">*</span></Label>
-              <div class="flex gap-2 items-center">
-                <Input
-                  id="sqlcipher-path"
-                  v-model="formData.host"
-                  :placeholder="t('components.serverForm.placeholders.filePath')"
-                  :class="{ 'border-destructive': formErrors.host }"
-                  readonly
-                  class="flex-1"
-                />
-                <Button
-                  type="button"
-                  variant="outline"
-                  size="sm"
-                  @click="selectDatabaseFile"
-                >
-                  {{ t('common.buttons.browse') }}
-                </Button>
-              </div>
-              <p v-if="formErrors.host" class="text-sm text-destructive">
-                {{ formErrors.host }}
-              </p>
-            </div>
-            <!-- Recent Databases -->
-            <div v-if="recentDatabases.length > 0" class="space-y-2">
-              <Label>{{ t('components.serverForm.labels.recentDatabases') }}</Label>
-              <div class="p-2 border rounded-md max-h-32 overflow-y-auto space-y-1">
-                <div
-                  v-for="db in recentDatabases"
-                  :key="db.path"
-                  class="text-sm p-1 rounded flex gap-2 cursor-pointer items-center hover:bg-muted"
-                  @click="selectRecentDatabase(db.path)"
-                >
-                  <span class="i-carbon-document text-muted-foreground h-4 w-4" />
-                  <span class="flex-1 truncate">{{ db.path }}</span>
-                  <span class="text-xs text-muted-foreground">{{ formatTimeAgo(db.timestamp) }}</span>
-                </div>
-              </div>
-            </div>
-            <div v-if="recentDatabases.length === 0" class="text-sm text-muted-foreground">
-              {{ t('components.serverForm.sqlite.recentEmpty') }}
-            </div>
+            <DatabaseFileField
+              v-model="formData.host"
+              engine="sqlite"
+              required
+              :label="t('components.serverForm.labels.databaseFilePath')"
+              :placeholder="t('components.serverForm.placeholders.filePath')"
+              :error-message="formErrors.host"
+              @picking="isPickingFile = $event"
+            />
           </template>
 
-          <!-- DuckDB: file picker only -->
+          <!-- DuckDB: same File / In-Memory split as SQLite -->
           <template v-else>
-            <div class="space-y-2">
-              <Label for="duckdb-path">{{ t('components.serverForm.labels.databaseFilePath') }}<span class="text-destructive ml-0.5">*</span></Label>
-              <div class="flex gap-2 items-center">
-                <Input
-                  id="duckdb-path"
+            <Tabs v-model="duckdbTab">
+              <TabsList class="grid grid-cols-2 w-full">
+                <TabsTrigger value="file">
+                  {{ t('components.serverForm.sqlite.modes.file') }}
+                </TabsTrigger>
+                <TabsTrigger value="in-memory">
+                  {{ t('components.serverForm.sqlite.modes.inMemory') }}
+                </TabsTrigger>
+              </TabsList>
+
+              <TabsContent value="file" class="space-y-4">
+                <DatabaseFileField
                   v-model="formData.host"
-                  :placeholder="t('components.serverForm.placeholders.filePath')"
-                  :class="{ 'border-destructive': formErrors.host }"
-                  readonly
-                  class="flex-1"
+                  engine="duckdb"
+                  required
+                  :label="t('components.serverForm.labels.databaseFilePath')"
+                  :placeholder="t('components.serverForm.placeholders.duckdbFilePath')"
+                  :error-message="formErrors.host"
+                  :suggested-name="formData.name ? `${formData.name}.duckdb` : undefined"
+                  @status="handleDuckDbFileStatus"
+                  @picking="isPickingFile = $event"
                 />
-                <Button
-                  type="button"
-                  variant="outline"
-                  size="sm"
-                  @click="selectDatabaseFile"
+
+                <p v-if="formData.serverVersion" class="text-xs text-muted-foreground">
+                  {{ t('components.serverForm.duckdb.engineVersion', { version: formData.serverVersion }) }}
+                </p>
+
+                <div class="space-y-2">
+                  <Label>{{ t('components.serverForm.duckdb.accessMode') }}</Label>
+                  <div class="gap-3 grid grid-cols-2" role="radiogroup">
+                    <button
+                      type="button"
+                      role="radio"
+                      :aria-checked="!formData.readOnly"
+                      class="p-3 text-left border-2 rounded-lg transition-colors" :class="[
+                        !formData.readOnly
+                          ? 'border-primary bg-primary/5'
+                          : 'border-border bg-card hover:border-muted-foreground/50',
+                      ]"
+                      @click="formData.readOnly = false"
+                    >
+                      <div class="mb-1 flex gap-2 items-center">
+                        <div
+                          class="border-2 rounded-full flex shrink-0 h-3.5 w-3.5 items-center justify-center" :class="[
+                            !formData.readOnly ? 'border-primary' : 'border-muted-foreground',
+                          ]"
+                        >
+                          <div v-if="!formData.readOnly" class="rounded-full bg-primary h-1.5 w-1.5" />
+                        </div>
+                        <span class="text-sm font-medium">
+                          {{ t('components.serverForm.duckdb.readWrite') }}
+                        </span>
+                      </div>
+                      <p class="text-xs text-muted-foreground leading-relaxed pl-5">
+                        {{ t('components.serverForm.duckdb.readWriteHint') }}
+                      </p>
+                    </button>
+                    <button
+                      type="button"
+                      role="radio"
+                      :aria-checked="formData.readOnly === true"
+                      class="p-3 text-left border-2 rounded-lg transition-colors" :class="[
+                        formData.readOnly
+                          ? 'border-primary bg-primary/5'
+                          : 'border-border bg-card hover:border-muted-foreground/50',
+                      ]"
+                      @click="formData.readOnly = true"
+                    >
+                      <div class="mb-1 flex gap-2 items-center">
+                        <div
+                          class="border-2 rounded-full flex shrink-0 h-3.5 w-3.5 items-center justify-center" :class="[
+                            formData.readOnly ? 'border-primary' : 'border-muted-foreground',
+                          ]"
+                        >
+                          <div v-if="formData.readOnly" class="rounded-full bg-primary h-1.5 w-1.5" />
+                        </div>
+                        <span class="text-sm font-medium">
+                          {{ t('components.serverForm.duckdb.readOnly') }}
+                        </span>
+                      </div>
+                      <p class="text-xs text-muted-foreground leading-relaxed pl-5">
+                        {{ t('components.serverForm.duckdb.readOnlyHint') }}
+                      </p>
+                    </button>
+                  </div>
+                </div>
+
+                <div
+                  v-if="conflictingDuckDbConnection"
+                  class="text-xs text-amber-600 p-2 border border-amber-500/50 rounded-md flex gap-2 items-start dark:text-amber-500"
                 >
-                  {{ t('common.buttons.browse') }}
-                </Button>
-              </div>
-              <p v-if="formErrors.host" class="text-sm text-destructive">
-                {{ formErrors.host }}
-              </p>
-            </div>
+                  <span class="i-carbon-warning mt-0.5 shrink-0 h-4 w-4" />
+                  <div class="flex-1 space-y-1">
+                    <p>{{ t('components.serverForm.duckdb.conflictingConnection', { name: conflictingDuckDbConnection.name }) }}</p>
+                    <div class="flex gap-2">
+                      <Button type="button" variant="outline" size="sm" class="text-xs px-2 h-6" @click="formData.readOnly = true">
+                        {{ t('components.serverForm.duckdb.openReadOnly') }}
+                      </Button>
+                      <Button type="button" variant="ghost" size="sm" class="text-xs px-2 h-6" @click="switchToConnection(conflictingDuckDbConnection)">
+                        {{ t('components.serverForm.duckdb.switchToConnection') }}
+                      </Button>
+                    </div>
+                  </div>
+                </div>
+
+                <p v-else-if="sharedDuckDbConnection" class="text-xs text-muted-foreground">
+                  {{ t('components.serverForm.duckdb.sharedConnection', { name: sharedDuckDbConnection.name }) }}
+                </p>
+              </TabsContent>
+
+              <!-- In-Memory Mode -->
+              <TabsContent value="in-memory" class="space-y-3">
+                <p class="text-sm text-muted-foreground">
+                  {{ t('components.serverForm.duckdb.inMemoryHint') }}
+                </p>
+                <div class="text-xs p-2 border rounded-md flex gap-2 items-center">
+                  <span class="i-carbon-data-table text-muted-foreground shrink-0 h-4 w-4" />
+                  <span class="text-muted-foreground">{{ t('components.serverForm.duckdb.inMemoryInstance') }}</span>
+                  <span class="font-mono flex-1 truncate" :title="formData.host">{{ formData.host || '-' }}</span>
+                </div>
+                <p class="text-xs text-muted-foreground">
+                  {{ t('components.serverForm.duckdb.inMemorySharedHint') }}
+                </p>
+                <p v-if="formData.serverVersion" class="text-xs text-muted-foreground">
+                  {{ t('components.serverForm.duckdb.engineVersion', { version: formData.serverVersion }) }}
+                </p>
+              </TabsContent>
+            </Tabs>
           </template>
         </div>
 
@@ -1498,6 +1588,35 @@ function handleSave() {
               <p v-if="testError" class="text-red-500 pl-5">
                 {{ testError }}
               </p>
+              <div
+                v-if="testFailureHint"
+                class="text-xs text-amber-600 pl-5 flex gap-2 items-start dark:text-amber-500"
+              >
+                <span class="i-carbon-warning mt-0.5 shrink-0 h-4 w-4" />
+                <div class="flex-1 space-y-1">
+                  <p>{{ t(testFailureHint.messageKey) }}</p>
+                  <Button
+                    v-if="testFailureHint.action === 'use-read-only'"
+                    type="button"
+                    variant="outline"
+                    size="sm"
+                    class="text-xs px-2 h-6"
+                    @click="retryAsReadOnly"
+                  >
+                    {{ t('components.serverForm.duckdb.retryReadOnly') }}
+                  </Button>
+                  <Button
+                    v-else-if="testFailureHint.action === 'use-read-write'"
+                    type="button"
+                    variant="outline"
+                    size="sm"
+                    class="text-xs px-2 h-6"
+                    @click="retryAsReadWrite"
+                  >
+                    {{ t('components.serverForm.duckdb.retryReadWrite') }}
+                  </Button>
+                </div>
+              </div>
             </div>
           </div>
         </div>
diff --git a/src/datasources/connectionApi.ts b/src/datasources/connectionApi.ts
index bfe4fcaa..34a1b78d 100644
--- a/src/datasources/connectionApi.ts
+++ b/src/datasources/connectionApi.ts
@@ -44,6 +44,7 @@ export type ServerConfig = {
   trust_server_certificate?: boolean | null
   transport_layers?: TransportLayerConfig[] | null
   oracle_options?: OracleConnectionOptions | null
+  read_only?: boolean | null
 }
 
 export type ConnectionStatus = {
diff --git a/src/lang/enUS.ts b/src/lang/enUS.ts
index ad2b8c82..1f333ec6 100644
--- a/src/lang/enUS.ts
+++ b/src/lang/enUS.ts
@@ -1026,6 +1026,7 @@ export const enUS = {
         selectType: 'Select database type',
         host: 'localhost',
         filePath: '/path/to/database.db',
+        duckdbFilePath: '/path/to/database.duckdb or :memory:',
         encryptionKey: 'Enter encryption passphrase',
         database: 'database_name',
         username: 'username',
@@ -1123,6 +1124,56 @@ export const enUS = {
         noAliases: 'No TNS aliases found',
         loadingAliases: 'Loading aliases...',
       },
+      buttons: {
+        create: 'New...',
+        open: 'Open...',
+      },
+      fileStatus: {
+        willCreate: 'File does not exist yet — {engine} creates it when you connect.',
+        missingParent: 'The parent folder does not exist yet.',
+        createDirectory: 'Create folder',
+        createDirectoryFailed: 'Failed to create the folder',
+        unwritable: 'No write permission for this path.',
+        directory: 'This path is a folder. Choose a database file instead.',
+        empty: 'The file is empty (0 bytes).',
+        ready: 'File exists ({size})',
+        storageVersion: 'Storage format {storage} (opens with DuckDB {version} or newer)',
+        storageVersionUnknown: 'Storage format {storage} — newer than this build knows, likely written by a newer DuckDB.',
+        writeAheadLog: 'A write-ahead log (.wal) is present; it is replayed on connect.',
+        unsupportedPath: 'DuckDB cannot open a path containing \';\'. Rename the file and try again.',
+        wrongFormat: 'This looks like a {format} file, not a {engine} database.',
+        unknownFormat: 'different',
+        reveal: 'Show in folder',
+        revealFailed: 'Failed to reveal the file',
+        removeRecent: 'Remove from recent list',
+      },
+      duckdb: {
+        accessMode: 'Access mode',
+        readWrite: 'Read & write',
+        readWriteHint: 'DuckDB keeps an exclusive lock on the file: only one process can write to it.',
+        readOnly: 'Read-only',
+        readOnlyHint: 'Allows other DuckDB processes to read the same file at the same time.',
+        conflictingConnection: '"{name}" already opens this file with a different access mode, and DuckDB rejects a second connection with a different configuration.',
+        openReadOnly: 'Open read-only',
+        switchToConnection: 'Switch to that connection',
+        sharedConnection: '"{name}" uses the same file and configuration — both connections share one DuckDB instance.',
+        engineVersion: 'Engine version {version}',
+        retryReadOnly: 'Retry as read-only',
+        retryReadWrite: 'Retry as read-write',
+        inMemoryHint: 'In-memory databases are temporary and are lost when the connection is closed. Useful for exploring data before saving it to a file.',
+        inMemoryInstance: 'Instance',
+        inMemorySharedHint: 'The named in-memory instance is shared by every pooled connection, so tables created in one query stay visible to the next.',
+      },
+      duckdbFailures: {
+        'read-only-unsupported': 'The installed JDBC bridge cannot open a database read-only yet (DuckDB refuses per-connection mode changes). Retry in read-write mode, or update the bridge in Settings.',
+        'storage-version': 'This file was written by a newer DuckDB than the engine in use, so it cannot be opened. Export it with the newer version (EXPORT DATABASE) and import it again, or update the DuckDB driver.',
+        'config-conflict': 'Another connection already opened this file with a different configuration (read-only vs read-write, or different initialization). DuckDB rejects the second configuration.',
+        'lock-conflict': 'Another process holds the write lock on this file (duckdb CLI, Python, or another SQLKit connection). Open it read-only, or close the other program.',
+        'unsupported-url': 'This path cannot be passed to DuckDB\'s JDBC driver. Rename the file and try again.',
+        'extension': 'A DuckDB extension could not be loaded or downloaded. Check the network connection or install the extension beforehand.',
+        'read-only-file': 'The database file or its folder is read-only, so DuckDB cannot write to it. Change the file permissions or open it read-only.',
+        'missing-file': 'The database file does not exist and could not be created. Check the path and the folder permissions.',
+      },
       sqlite: {
         modes: {
           file: 'File',
diff --git a/src/lang/zhCN.ts b/src/lang/zhCN.ts
index f0869815..8348acc8 100644
--- a/src/lang/zhCN.ts
+++ b/src/lang/zhCN.ts
@@ -1026,6 +1026,8 @@ export const zhCN = {
         selectType: '选择数据库类型',
         host: 'localhost',
         filePath: '/path/to/database.db',
+        encryptionKey: '输入加密口令',
+        duckdbFilePath: '/path/to/database.duckdb 或 :memory:',
         database: 'database_name',
         username: 'username',
         password: '••••••••',
@@ -1122,6 +1124,56 @@ export const zhCN = {
         noAliases: '未找到 TNS 别名',
         loadingAliases: '加载别名中...',
       },
+      buttons: {
+        create: '新建...',
+        open: '打开...',
+      },
+      fileStatus: {
+        willCreate: '文件不存在，连接时将由 {engine} 自动创建。',
+        missingParent: '上级目录不存在。',
+        createDirectory: '创建目录',
+        createDirectoryFailed: '创建目录失败',
+        unwritable: '该路径没有写入权限。',
+        directory: '该路径是一个目录，请改为选择数据库文件。',
+        empty: '文件为空（0 字节）。',
+        ready: '文件已存在（{size}）',
+        storageVersion: '存储格式 {storage}（需 DuckDB {version} 及更新版本打开）',
+        storageVersionUnknown: '存储格式 {storage} —— 比本版本已知的格式更新，可能由更新的 DuckDB 写入。',
+        writeAheadLog: '存在未合并的 WAL 文件，连接时会自动重放。',
+        unsupportedPath: '路径包含 “;”，DuckDB 的 JDBC 驱动无法打开；请重命名文件后再试。',
+        wrongFormat: '这看起来是 {format} 文件，不是 {engine} 数据库。',
+        unknownFormat: '其他格式',
+        reveal: '在文件夹中显示',
+        revealFailed: '无法在文件夹中定位该文件',
+        removeRecent: '从最近列表移除',
+      },
+      duckdb: {
+        accessMode: '访问模式',
+        readWrite: '读写',
+        readWriteHint: 'DuckDB 会对文件加独占锁：同一时刻只允许一个进程写入。',
+        readOnly: '只读',
+        readOnlyHint: '允许其他 DuckDB 进程同时读取同一个文件。',
+        conflictingConnection: '“{name}”已用不同的访问模式打开该文件，DuckDB 会拒绝配置不一致的第二个连接。',
+        openReadOnly: '以只读打开',
+        switchToConnection: '切换到该连接',
+        sharedConnection: '“{name}”使用相同文件与配置，两个连接会共享同一个 DuckDB 实例。',
+        engineVersion: '引擎版本 {version}',
+        retryReadOnly: '以只读重新测试',
+        retryReadWrite: '以读写重新测试',
+        inMemoryHint: '内存数据库是临时的，连接关闭后数据将丢失。适合先探索数据，再另存为文件。',
+        inMemoryInstance: '实例名',
+        inMemorySharedHint: '命名内存实例由连接池中的所有连接共享，因此一次查询创建的表在下一次查询中依然可见。',
+      },
+      duckdbFailures: {
+        'read-only-unsupported': '当前 JDBC bridge 还无法以只读方式打开数据库（DuckDB 不允许在连接级别切换只读）。可改用读写模式，或在设置里更新 bridge。',
+        'storage-version': '该文件由更新版本的 DuckDB 写入，当前引擎无法打开。请用新版本执行 EXPORT DATABASE 后再导入，或升级 DuckDB 驱动。',
+        'config-conflict': '已有另一个连接用不同配置打开该文件（只读/读写、或初始化不同），DuckDB 会拒绝第二个配置。',
+        'lock-conflict': '该文件正被其他进程以读写方式占用（duckdb CLI、Python 或 SQLKit 的另一个连接）。可改用只读打开，或关闭占用它的程序。',
+        'unsupported-url': '该路径无法传给 DuckDB 的 JDBC 驱动，请重命名文件后重试。',
+        'extension': 'DuckDB 扩展加载或下载失败，请检查网络，或提前安装该扩展。',
+        'read-only-file': '数据库文件或其目录是只读的，DuckDB 无法写入。请调整文件权限，或改为只读打开。',
+        'missing-file': '数据库文件不存在且无法创建，请检查路径与目录权限。',
+      },
       sqlite: {
         modes: {
           file: '文件',
diff --git a/src/store/connectionStore.ts b/src/store/connectionStore.ts
index 12f312a0..f9b6705e 100644
--- a/src/store/connectionStore.ts
+++ b/src/store/connectionStore.ts
@@ -415,6 +415,8 @@ export type ServerConnection = {
   ssl: SslConfig
   sshTunnel?: SSHTunnelConfig
   oracleOptions?: OracleConnectionOptions
+  /** Open a local database file read-only (DuckDB supports this today). */
+  readOnly?: boolean
   connectTimeoutSecs?: number
   queryTimeoutSecs?: number
   isConnected?: boolean
@@ -645,6 +647,7 @@ export const useConnectionStore = defineStore('connectionStore', {
             },
             sshTunnel: extractSshTunnelFromTransport(item.transport_layers),
             oracleOptions: extractOracleOptions(item.oracle_options),
+            readOnly: (item.read_only as boolean | undefined) ?? false,
             isConnected: prev?.isConnected ?? (item.is_connected as boolean | undefined),
             lastUsed: item.last_used ? new Date(item.last_used as string) : undefined,
             serverVersion: prev?.serverVersion,
@@ -677,6 +680,7 @@ export const useConnectionStore = defineStore('connectionStore', {
           trust_server_certificate: connection.ssl.trustServerCertificate ?? false,
           transport_layers: transportLayers,
           oracle_options: buildOracleOptions(connection.oracleOptions),
+          read_only: connection.readOnly ?? false,
         }
 
         const resultId = await connectionApi.save(serverConfig)
@@ -727,6 +731,7 @@ export const useConnectionStore = defineStore('connectionStore', {
           query_timeout_secs: connection.queryTimeoutSecs ?? 30,
           transport_layers: transportLayers,
           oracle_options: buildOracleOptions(connection.oracleOptions),
+          read_only: connection.readOnly ?? false,
         }
 
         const result = await connectionApi.test(serverConfig)
@@ -770,6 +775,7 @@ export const useConnectionStore = defineStore('connectionStore', {
           query_timeout_secs: connection.queryTimeoutSecs ?? 30,
           transport_layers: transportLayers,
           oracle_options: buildOracleOptions(connection.oracleOptions),
+          read_only: connection.readOnly ?? false,
         }
 
         const result = await connectionApi.connect(serverConfig)
diff --git a/src/utils/databaseFiles.ts b/src/utils/databaseFiles.ts
new file mode 100644
index 00000000..6bd1d30d
--- /dev/null
+++ b/src/utils/databaseFiles.ts
@@ -0,0 +1,215 @@
+/**
+ * Pure helpers for file-based database connections (SQLite / SQLCipher / DuckDB).
+ *
+ * Kept side-effect free so the connection form logic stays testable: the Tauri
+ * probe command (`probe_database_file`) and the dialogs live in the components.
+ */
+
+export type DatabaseFileFormat = 'duckdb' | 'sqlite' | 'unknown'
+
+export type DatabaseFileProbe = {
+  path: string
+  exists: boolean
+  isDirectory: boolean
+  sizeBytes: number | null
+  parentExists: boolean
+  parentWritable: boolean
+  writable: boolean
+  format: DatabaseFileFormat | null
+  /** DuckDB storage-format version read from the file header. */
+  storageVersion: number | null
+  /** Whether a sibling `<file>.wal` write-ahead log exists. */
+  hasWal: boolean
+}
+
+export type DatabaseFileStatus
+  = | 'memory'
+    | 'unknown'
+    | 'will-create'
+    | 'missing-parent'
+    | 'unwritable'
+    | 'directory'
+    | 'empty'
+    | 'ready'
+    | 'wrong-format'
+    | 'unsupported-path'
+
+export type DatabaseFileAssessment = {
+  status: DatabaseFileStatus
+  format: DatabaseFileFormat | null
+  sizeBytes: number | null
+}
+
+export type RecentDatabaseEntry = {
+  path: string
+  timestamp: number
+}
+
+export const DUCKDB_EXTENSION = 'duckdb'
+export const SQLITE_EXTENSIONS = ['db', 'sqlite', 'sqlite3', 'sqlcipher', 'db3']
+export const DUCKDB_EXTENSIONS = ['duckdb', 'db']
+export const DUCKDB_MEMORY_PREFIX = 'memory:'
+export const MAX_RECENT_DATABASES = 10
+
+const RECENT_KEYS: Record<'sqlite' | 'duckdb', string> = {
+  sqlite: 'sqlite_recent_databases',
+  duckdb: 'duckdb_recent_databases',
+}
+
+/** localStorage key holding the recent database list for the given engine. */
+export const recentDatabasesKey = (engine: 'sqlite' | 'duckdb'): string => RECENT_KEYS[engine]
+
+/**
+ * DuckDB in-memory databases are per-connection instances, so the pooled
+ * JDBC connections would otherwise each open their own empty database.
+ * A named instance (`jdbc:duckdb:memory:<label>`) is shared by every
+ * connection that uses the same label.
+ */
+export function isMemoryDatabaseHost(host: string): boolean {
+  return host === ':memory:' || host.startsWith(DUCKDB_MEMORY_PREFIX)
+}
+
+export const buildMemoryDatabaseHost = (label: string): string => `${DUCKDB_MEMORY_PREFIX}${label}`
+
+export function memoryDatabaseLabel(host: string): string {
+  return isMemoryDatabaseHost(host) ? host.slice(DUCKDB_MEMORY_PREFIX.length) : ''
+}
+
+export function createMemoryDatabaseLabel(): string {
+  return `sqlkit_${Math.random().toString(36).slice(2, 10)}`
+}
+
+/** Append `.<extension>` unless the file name already carries an extension. */
+export function withDatabaseExtension(path: string, extension: string): string {
+  const trimmed = path.trim()
+  if (!trimmed)
+    return trimmed
+
+  const separatorIndex = Math.max(trimmed.lastIndexOf('/'), trimmed.lastIndexOf('\\'))
+  const fileName = trimmed.slice(separatorIndex + 1)
+  if (fileName.includes('.'))
+    return trimmed
+
+  return `${trimmed}.${extension}`
+}
+
+/**
+ * Path form used for duplicate detection: trailing separators removed and
+ * case-folded on case-insensitive file systems (macOS, Windows).
+ */
+export function normalizeComparablePath(path: string, platform: string): string {
+  const collapsed = path.trim().replace(/[/\\]+$/, '')
+  const caseInsensitive = platform === 'macos' || platform === 'windows'
+  return caseInsensitive ? collapsed.toLowerCase() : collapsed
+}
+
+export function isSameDatabaseFile(a: string, b: string, platform: string): boolean {
+  return Boolean(a && b) && normalizeComparablePath(a, platform) === normalizeComparablePath(b, platform)
+}
+
+/** Human-readable file size, e.g. `1.2 MB`. */
+export function formatFileSize(bytes: number | null | undefined): string {
+  if (bytes === null || bytes === undefined || Number.isNaN(bytes))
+    return ''
+  if (bytes < 1024)
+    return `${bytes} B`
+
+  const units = ['KB', 'MB', 'GB', 'TB']
+  const exponent = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length)
+  const value = bytes / 1024 ** exponent
+  return `${value.toFixed(value >= 10 ? 0 : 1)} ${units[exponent - 1]}`
+}
+
+/**
+ * Oldest DuckDB release that can open a file with the given storage version.
+ *
+ * Values come from DuckDB's storage-version table; 64 is what `duckdb_jdbc`
+ * 1.5.6 writes for a plain file, and the engine itself reports it as
+ * `storage_version=v1.0.0+`. Unknown (newer) numbers are surfaced raw so a
+ * "this file cannot be opened" report can be diagnosed.
+ */
+const STORAGE_VERSION_MIN_RELEASE: Record<number, string> = {
+  1: 'v0.2.1',
+  4: 'v0.2.2',
+  6: 'v0.2.3',
+  11: 'v0.2.4',
+  13: 'v0.2.5',
+  15: 'v0.2.6',
+  17: 'v0.2.7',
+  18: 'v0.2.8',
+  21: 'v0.2.9',
+  25: 'v0.3.0',
+  27: 'v0.3.1',
+  31: 'v0.3.2',
+  33: 'v0.3.3',
+  38: 'v0.5.0',
+  39: 'v0.6.0',
+  43: 'v0.7.0',
+  51: 'v0.8.0',
+  64: 'v1.0.0',
+  65: 'v1.2.0',
+  66: 'v1.3.0',
+}
+
+/** Oldest DuckDB release able to read a file with this storage version. */
+export function storageVersionMinRelease(storageVersion: number | null): string | null {
+  if (storageVersion === null || storageVersion === undefined)
+    return null
+  return STORAGE_VERSION_MIN_RELEASE[storageVersion] ?? null
+}
+
+/**
+ * Turn a probe result into the state the form should explain to the user.
+ * `expectedFormat` is the engine the connection is being created for.
+ */
+export function assessDatabaseFile(probe: DatabaseFileProbe | null, expectedFormat: DatabaseFileFormat, host: string): DatabaseFileAssessment {
+  if (isMemoryDatabaseHost(host))
+    return { status: 'memory', format: null, sizeBytes: null }
+
+  // Verified against duckdb_jdbc 1.5.6: the driver splits the connection URL on
+  // ';' before opening the database, so such a path cannot be opened at all.
+  if (expectedFormat === 'duckdb' && host.includes(';'))
+    return { status: 'unsupported-path', format: null, sizeBytes: null }
+
+  if (!host.trim())
+    return { status: 'unknown', format: null, sizeBytes: null }
+
+  if (!probe)
+    return { status: 'unknown', format: null, sizeBytes: null }
+
+  if (probe.isDirectory)
+    return { status: 'directory', format: null, sizeBytes: probe.sizeBytes }
+
+  if (!probe.exists) {
+    if (!probe.parentExists)
+      return { status: 'missing-parent', format: null, sizeBytes: null }
+    return probe.parentWritable
+      ? { status: 'will-create', format: null, sizeBytes: null }
+      : { status: 'unwritable', format: null, sizeBytes: null }
+  }
+
+  if (!probe.writable)
+    return { status: 'unwritable', format: probe.format, sizeBytes: probe.sizeBytes }
+
+  if (probe.sizeBytes === 0)
+    return { status: 'empty', format: probe.format, sizeBytes: 0 }
+
+  if (probe.format && probe.format !== expectedFormat)
+    return { status: 'wrong-format', format: probe.format, sizeBytes: probe.sizeBytes }
+
+  return { status: 'ready', format: probe.format, sizeBytes: probe.sizeBytes }
+}
+
+/** Newest first, de-duplicated by path, capped at `limit`. */
+export function mergeRecentDatabase(entries: RecentDatabaseEntry[], path: string, timestamp: number, limit: number = MAX_RECENT_DATABASES): RecentDatabaseEntry[] {
+  return [
+    { path, timestamp },
+    ...entries.filter(entry => entry.path !== path),
+  ].slice(0, limit)
+}
+
+/** Ensure a file name is offered in the platform save dialog. */
+export function suggestDatabaseFileName(label?: string): string {
+  const base = (label || 'database').trim().replace(/[/\\:*?"<>|]+/g, '-').replace(/\s+/g, '-')
+  return withDatabaseExtension(base || 'database', DUCKDB_EXTENSION)
+}
diff --git a/src/utils/duckdbErrors.ts b/src/utils/duckdbErrors.ts
new file mode 100644
index 00000000..440252db
--- /dev/null
+++ b/src/utils/duckdbErrors.ts
@@ -0,0 +1,140 @@
+/**
+ * Maps raw DuckDB connection failures onto a short explanation (and, when it is
+ * actionable, the action that fixes them).
+ *
+ * DuckDB has a small set of very characteristic failures — exclusive file locks,
+ * instance-scoped configuration, one-way storage-format compatibility — and users
+ * hit them exactly when they create and share files locally. Signatures were
+ * verified against `duckdb_jdbc` 1.5.6 (see scripts/verify-duckdb-jdbc-urls.sh).
+ */
+
+export type DuckDbFailureKind
+  = | 'read-only-unsupported'
+    | 'storage-version'
+    | 'config-conflict'
+    | 'lock-conflict'
+    | 'unsupported-url'
+    | 'extension'
+    | 'read-only-file'
+    | 'missing-file'
+
+export type DuckDbFailureHint = {
+  kind: DuckDbFailureKind
+  /** i18n key of the user-facing explanation. */
+  messageKey: string
+  /** Action the UI can offer inline, when one exists. */
+  action?: 'use-read-only' | 'use-read-write'
+}
+
+type Signature = {
+  kind: DuckDbFailureKind
+  patterns: string[]
+  action?: 'use-read-only' | 'use-read-write'
+  /**
+   * Generic patterns (e.g. "no such file or directory") also appear in other
+   * engines' errors, so they only count when the message mentions DuckDB.
+   */
+  generic?: boolean
+}
+
+const DUCKDB_CONTEXT = /duckdb/i
+
+const SIGNATURES: Signature[] = [
+  {
+    // DuckDB refuses setReadOnly() at connection level, so a JDBC bridge that
+    // does not align HikariCP's read-only flag with the URL fails on a read-only
+    // connection. Fixed in the bridge; reported clearly until it ships.
+    kind: 'read-only-unsupported',
+    patterns: [
+      'can\'t change read-only status',
+      'cannot change read-only status',
+    ],
+    action: 'use-read-write',
+  },
+  {
+    kind: 'storage-version',
+    patterns: [
+      'serialization error',
+      'failed to deserialize',
+      'storage version',
+      'incompatible storage',
+      'created with a newer version',
+      'written by a newer version',
+    ],
+  },
+  {
+    kind: 'config-conflict',
+    patterns: [
+      'different configuration than existing connections',
+      'same database file with a different configuration',
+    ],
+    action: 'use-read-only',
+  },
+  {
+    kind: 'lock-conflict',
+    patterns: [
+      'could not set lock',
+      'conflicting lock is held',
+      'file is locked',
+      'being used by another process',
+      'already open in another',
+    ],
+    action: 'use-read-only',
+  },
+  {
+    kind: 'unsupported-url',
+    patterns: ['invalid url entry', 'splits the connection url', 'database path containing'],
+  },
+  {
+    kind: 'extension',
+    patterns: [
+      'failed to download extension',
+      'unable to load extension',
+      'extension not found',
+      'extension "',
+    ],
+    generic: true,
+  },
+  {
+    kind: 'read-only-file',
+    patterns: [
+      'read-only file system',
+      'attempting to write to a read-only',
+      'cannot write to a read-only',
+      'read-only database',
+    ],
+    generic: true,
+  },
+  {
+    kind: 'missing-file',
+    patterns: [
+      'no such file or directory',
+      'cannot open file',
+      'does not exist',
+      'no such database',
+    ],
+    generic: true,
+  },
+]
+
+/** Explain a DuckDB connection failure, or return `null` when unrecognised. */
+export function classifyDuckDbFailure(message: string | null | undefined): DuckDbFailureHint | null {
+  const text = (message ?? '').toLowerCase()
+  if (!text)
+    return null
+
+  const mentionsDuckDb = DUCKDB_CONTEXT.test(text)
+
+  const match = SIGNATURES.find(signature =>
+    (mentionsDuckDb || !signature.generic)
+    && signature.patterns.some(pattern => text.includes(pattern)),
+  )
+  if (!match)
+    return null
+
+  return {
+    kind: match.kind,
+    messageKey: `components.serverForm.duckdbFailures.${match.kind}`,
+    action: match.action,
+  }
+}